From 8d6cdd5a246d141ce486a74d946997617aa0d259 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 28 Jun 2024 04:45:01 +0000 Subject: [PATCH 01/67] Library functions for temporal causal functionality --- dowhy/timeseries/timeseries.py | 82 ++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 dowhy/timeseries/timeseries.py diff --git a/dowhy/timeseries/timeseries.py b/dowhy/timeseries/timeseries.py new file mode 100644 index 000000000..073a69bd9 --- /dev/null +++ b/dowhy/timeseries/timeseries.py @@ -0,0 +1,82 @@ +import networkx as nx +import pandas as pd +import matplotlib.pyplot as plt + +def create_graph_from_user(): + # Initialize an empty directed graph + graph = nx.DiGraph() + + # Instructions for the user + print("Enter the graph as a list of edges with time lags. Enter 'done' when you are finished.") + print("Each edge should be entered in the format 'node1 node2 time_lag'. For example: 'A B 4'") + + # Loop to receive user input + while True: + edge = input("Enter an edge: ") + if edge.lower() == "done": + break + edge = edge.split() + if len(edge) != 3: + print("Invalid edge. Please enter an edge in the format 'node1 node2 time_lag'.") + continue + node1, node2, time_lag = edge + try: + time_lag = float(time_lag) + except ValueError: + print("Invalid weight. Please enter a numerical value for the time_lag.") + continue + graph.add_edge(node1, node2, time_lag=time_lag) + + return graph + +def create_graph_from_csv(file_path): + # Read the CSV file into a DataFrame + df = pd.read_csv(file_path) + + # Initialize an empty directed graph + graph = nx.DiGraph() + + # Add edges with weights to the graph + for index, row in df.iterrows(): + graph.add_edge(row['node1'], row['node2'], time_lag=row['time_lag']) + + return graph + +def pretty_print_graph(graph): + # Display the entered graph + print("\nGraph edges with time lags:") + for edge in graph.edges(data=True): + print(f"{edge[0]} -> {edge[1]} with time-lagged dependency {edge[2]['time_lag']}") + +def display_networkx_graph(graph): + # Draw and display the graph + pos = nx.spring_layout(graph) + nx.draw(graph, pos, with_labels=True) + labels = nx.get_edge_attributes(graph, 'time_lag') + nx.draw_networkx_edge_labels(graph, pos, edge_labels=labels) + plt.show() + +def find_lagged_parent_nodes(graph, node): + parent_nodes = {} + for n in graph.predecessors(node): + edge_data = graph.get_edge_data(n, node) + if 'time_lag' in edge_data: + parent_nodes[str(n)] = edge_data['time_lag'] + return parent_nodes + +# once we have the parent dictionary then we can parse it and shift columns within the dataframe with the appropriate lag +def shift_columns(df, parents): + new_df = df.copy() + for column, shift in parents.items(): + column=str(column) + if shift > 0: + new_df[column] = new_df[column].shift(shift, axis=0, fill_value=None) + # elif shift < 0: + # new_df[column] = new_df[column].shift(shift, axis=0, fill_value=None) + # new_df.drop(new_df.index[0:abs(shift)], axis=0, inplace=True) + return new_df + +def filter_columns(df, child_node, parent_nodes): + columns_to_keep = [str(child_node)] + list(parent_nodes.keys()) + filtered_df = df[columns_to_keep] + return filtered_df From 87a90b4e512258cead000d6c9358c379ff741d81 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Tue, 2 Jul 2024 05:06:27 +0000 Subject: [PATCH 02/67] shifting plotter function --- dowhy/utils/plotting.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/dowhy/utils/plotting.py b/dowhy/utils/plotting.py index 2f67001cc..e8a978303 100644 --- a/dowhy/utils/plotting.py +++ b/dowhy/utils/plotting.py @@ -199,3 +199,9 @@ def _plot_as_pyplot_figure(pygraphviz_graph: Any, figure_size: Optional[Tuple[in if figure_size is not None: plt.rcParams["figure.figsize"] = org_fig_size + +def pretty_print_graph(graph): + # Display the entered graph + print("\nGraph edges with time lags:") + for edge in graph.edges(data=True): + print(f"{edge[0]} -> {edge[1]} with time-lagged dependency {edge[2]['time_lag']}") \ No newline at end of file From ec73c1a903315e6d7a6086cf8b82b7118ea94be1 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Tue, 2 Jul 2024 05:07:34 +0000 Subject: [PATCH 03/67] modified helper functions --- dowhy/timeseries/timeseries.py | 32 +++++++++++++++++++++----------- 1 file changed, 21 insertions(+), 11 deletions(-) diff --git a/dowhy/timeseries/timeseries.py b/dowhy/timeseries/timeseries.py index 073a69bd9..462262055 100644 --- a/dowhy/timeseries/timeseries.py +++ b/dowhy/timeseries/timeseries.py @@ -30,24 +30,36 @@ def create_graph_from_user(): return graph def create_graph_from_csv(file_path): + """ + Creates a directed graph from a CSV file. + + The CSV file should have at least three columns: 'node1', 'node2', and 'time_lag'. + Each row represents an edge from 'node1' to 'node2' with a 'time_lag' attribute. + + Parameters: + - file_path (str): The path to the CSV file. + + Returns: + - nx.DiGraph: A directed graph created from the CSV file. + + Example CSV content: + node1,node2,time_lag + A,B,5 + B,C,2 + A,C,7 + """ # Read the CSV file into a DataFrame df = pd.read_csv(file_path) # Initialize an empty directed graph graph = nx.DiGraph() - # Add edges with weights to the graph + # Add edges with time lag to the graph for index, row in df.iterrows(): graph.add_edge(row['node1'], row['node2'], time_lag=row['time_lag']) return graph -def pretty_print_graph(graph): - # Display the entered graph - print("\nGraph edges with time lags:") - for edge in graph.edges(data=True): - print(f"{edge[0]} -> {edge[1]} with time-lagged dependency {edge[2]['time_lag']}") - def display_networkx_graph(graph): # Draw and display the graph pos = nx.spring_layout(graph) @@ -71,10 +83,8 @@ def shift_columns(df, parents): column=str(column) if shift > 0: new_df[column] = new_df[column].shift(shift, axis=0, fill_value=None) - # elif shift < 0: - # new_df[column] = new_df[column].shift(shift, axis=0, fill_value=None) - # new_df.drop(new_df.index[0:abs(shift)], axis=0, inplace=True) - return new_df + filled_df=new_df.fillna(0) + return filled_df def filter_columns(df, child_node, parent_nodes): columns_to_keep = [str(child_node)] + list(parent_nodes.keys()) From 6d22554743069c12e2b482ae1c051043ef8c39a7 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Tue, 2 Jul 2024 05:08:01 +0000 Subject: [PATCH 04/67] tutorial notebook --- dowhy/timeseries/causal_effect_tutorial.ipynb | 432 ++++++++++++++++++ dowhy/timeseries/temporal_dataset.csv | 11 + dowhy/timeseries/temporal_graph.csv | 6 + 3 files changed, 449 insertions(+) create mode 100644 dowhy/timeseries/causal_effect_tutorial.ipynb create mode 100644 dowhy/timeseries/temporal_dataset.csv create mode 100644 dowhy/timeseries/temporal_graph.csv diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb new file mode 100644 index 000000000..3beab3cda --- /dev/null +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -0,0 +1,432 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import networkx as nx\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Taking Causal Graph as Input" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "from dowhy.timeseries.timeseries import create_graph_from_csv\n", + "from dowhy.timeseries.timeseries import create_graph_from_user\n", + "from dowhy.timeseries.timeseries import display_networkx_graph\n", + "from dowhy.utils.plotting import pretty_print_graph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- The user can either create a csv file with the edges in the graph or input the edges manually" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Graph edges with time lags:\n", + "1 -> 2 with time-lagged dependency 3\n", + "2 -> 3 with time-lagged dependency 4\n", + "5 -> 6 with time-lagged dependency 1\n", + "4 -> 7 with time-lagged dependency 4\n", + "7 -> 6 with time-lagged dependency 3\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Prompt user to input the path to the CSV file\n", + "file_path = \"./temporal_graph.csv\"\n", + "\n", + "# Create the graph from the CSV file\n", + "graph = create_graph_from_csv(file_path)\n", + "pretty_print_graph(graph)\n", + "display_networkx_graph(graph)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dataset Shifting and Preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from dowhy.timeseries.timeseries import find_lagged_parent_nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'5': 1, '7': 3}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# read the dataframe in a csv format from the user, and then ask the user to select any 2 rows for \n", + "# the effect estimation usecase\n", + "dataset_path=\"temporal_dataset.csv\"\n", + "dataframe=pd.read_csv(dataset_path)\n", + "\n", + "# the node for which effect estimation has to be done, node:6\n", + "child_node = 6\n", + "# find the parent nodes of the given node with respective lag times\n", + "parents = find_lagged_parent_nodes(graph, child_node)\n", + "parents" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from dowhy.timeseries.timeseries import shift_columns,filter_columns" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
1234567
012340.060.0
123455.070.0
234566.080.0
345677.097.0
401578.098.0
\n", + "
" + ], + "text/plain": [ + " 1 2 3 4 5 6 7\n", + "0 1 2 3 4 0.0 6 0.0\n", + "1 2 3 4 5 5.0 7 0.0\n", + "2 3 4 5 6 6.0 8 0.0\n", + "3 4 5 6 7 7.0 9 7.0\n", + "4 0 1 5 7 8.0 9 8.0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "time_shifted_df = shift_columns(dataframe,parents)\n", + "time_shifted_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
657
060.00.0
175.00.0
286.00.0
397.07.0
498.08.0
\n", + "
" + ], + "text/plain": [ + " 6 5 7\n", + "0 6 0.0 0.0\n", + "1 7 5.0 0.0\n", + "2 8 6.0 0.0\n", + "3 9 7.0 7.0\n", + "4 9 8.0 8.0" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "filtered_ts_df = filter_columns(time_shifted_df,child_node,parents)\n", + "filtered_ts_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cause Estimation using Dowhy" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*** Causal Estimate ***\n", + "\n", + "## Identified estimand\n", + "Estimand type: EstimandType.NONPARAMETRIC_ATE\n", + "\n", + "### Estimand : 1\n", + "Estimand name: backdoor\n", + "Estimand expression:\n", + " d \n", + "────(E[6])\n", + "d[5] \n", + "Estimand assumption 1, Unconfoundedness: If U→{5} and U→6 then P(6|5,,U) = P(6|5,)\n", + "\n", + "## Realized estimand\n", + "b: 6~5\n", + "Target units: ate\n", + "\n", + "## Estimate\n", + "Mean value: 0.21739130434782616\n", + "p-value: [0.24486798]\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/scipy/stats/_axis_nan_policy.py:531: UserWarning: kurtosistest only valid for n>=20 ... continuing anyway, n=10\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n" + ] + } + ], + "source": [ + "# perform causal effect estimation on this new dataset\n", + "import dowhy\n", + "from dowhy import CausalModel\n", + "\n", + "# Assuming 'df' is your DataFrame, 'treatment' is your treatment variable, and 'outcome' is your outcome variable\n", + "# Also assuming 'common_causes' is a list of common cause variables\n", + "\n", + "model = CausalModel(\n", + " data=filtered_ts_df,\n", + " treatment='5',\n", + " outcome='6',\n", + " proceed_when_unidentifiable=True # Proceed even if the causal graph is not fully identifiable\n", + ")\n", + "\n", + "identified_estimand = model.identify_effect()\n", + "\n", + "estimate = model.estimate_effect(identified_estimand,\n", + " method_name=\"backdoor.linear_regression\",\n", + " test_significance=True)\n", + "\n", + "print(estimate)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/dowhy/timeseries/temporal_dataset.csv b/dowhy/timeseries/temporal_dataset.csv new file mode 100644 index 000000000..ef85d5703 --- /dev/null +++ b/dowhy/timeseries/temporal_dataset.csv @@ -0,0 +1,11 @@ +1,2,3,4,5,6,7 +1,2,3,4,5,6,7 +2,3,4,5,6,7,8 +3,4,5,6,7,8,9 +4,5,6,7,8,9,10 +0,1,5,7,8,9,7 +3,5,4,1,2,6,5 +6,7,1,2,4,5,9 +12,3,5,7,3,8,9 +3,2,1,6,3,8,9 +4,6,3,5,8,9,1 \ No newline at end of file diff --git a/dowhy/timeseries/temporal_graph.csv b/dowhy/timeseries/temporal_graph.csv new file mode 100644 index 000000000..2bb1c860f --- /dev/null +++ b/dowhy/timeseries/temporal_graph.csv @@ -0,0 +1,6 @@ +node1,node2,time_lag +1,2,3 +2,3,4 +5,6,1 +4,7,4 +7,6,3 \ No newline at end of file From 17f5822a69d14de4c9b5a707ceb07792661118b7 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 4 Jul 2024 03:19:04 +0000 Subject: [PATCH 05/67] graph creation into utils --- dowhy/timeseries/timeseries.py | 63 ++-------------------------- dowhy/utils/timeseries.py | 75 ++++++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+), 60 deletions(-) create mode 100644 dowhy/utils/timeseries.py diff --git a/dowhy/timeseries/timeseries.py b/dowhy/timeseries/timeseries.py index 462262055..c136e964b 100644 --- a/dowhy/timeseries/timeseries.py +++ b/dowhy/timeseries/timeseries.py @@ -2,64 +2,6 @@ import pandas as pd import matplotlib.pyplot as plt -def create_graph_from_user(): - # Initialize an empty directed graph - graph = nx.DiGraph() - - # Instructions for the user - print("Enter the graph as a list of edges with time lags. Enter 'done' when you are finished.") - print("Each edge should be entered in the format 'node1 node2 time_lag'. For example: 'A B 4'") - - # Loop to receive user input - while True: - edge = input("Enter an edge: ") - if edge.lower() == "done": - break - edge = edge.split() - if len(edge) != 3: - print("Invalid edge. Please enter an edge in the format 'node1 node2 time_lag'.") - continue - node1, node2, time_lag = edge - try: - time_lag = float(time_lag) - except ValueError: - print("Invalid weight. Please enter a numerical value for the time_lag.") - continue - graph.add_edge(node1, node2, time_lag=time_lag) - - return graph - -def create_graph_from_csv(file_path): - """ - Creates a directed graph from a CSV file. - - The CSV file should have at least three columns: 'node1', 'node2', and 'time_lag'. - Each row represents an edge from 'node1' to 'node2' with a 'time_lag' attribute. - - Parameters: - - file_path (str): The path to the CSV file. - - Returns: - - nx.DiGraph: A directed graph created from the CSV file. - - Example CSV content: - node1,node2,time_lag - A,B,5 - B,C,2 - A,C,7 - """ - # Read the CSV file into a DataFrame - df = pd.read_csv(file_path) - - # Initialize an empty directed graph - graph = nx.DiGraph() - - # Add edges with time lag to the graph - for index, row in df.iterrows(): - graph.add_edge(row['node1'], row['node2'], time_lag=row['time_lag']) - - return graph - def display_networkx_graph(graph): # Draw and display the graph pos = nx.spring_layout(graph) @@ -77,7 +19,8 @@ def find_lagged_parent_nodes(graph, node): return parent_nodes # once we have the parent dictionary then we can parse it and shift columns within the dataframe with the appropriate lag -def shift_columns(df, parents): +def shift_columns(df:pd.DataFrame, parents:dict) -> pd.DataFrame: + # rename parents to columns and allow lag parameter new_df = df.copy() for column, shift in parents.items(): column=str(column) @@ -86,7 +29,7 @@ def shift_columns(df, parents): filled_df=new_df.fillna(0) return filled_df -def filter_columns(df, child_node, parent_nodes): +def filter_columns(df:pd.DataFrame, child_node, parent_nodes) -> pd.DataFrame: columns_to_keep = [str(child_node)] + list(parent_nodes.keys()) filtered_df = df[columns_to_keep] return filtered_df diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py new file mode 100644 index 000000000..0e729c5b6 --- /dev/null +++ b/dowhy/utils/timeseries.py @@ -0,0 +1,75 @@ +import networkx as nx +import pandas as pd + +def create_graph_from_user() -> nx.DiGraph: + """ + Creates a directed graph based on user input from the console. + + The user is prompted to enter edges one by one in the format 'node1 node2 time_lag', + where 'node1' and 'node2' are the nodes connected by the edge, and 'time_lag' is a numerical + value representing the weight of the edge. The user should enter 'done' to finish inputting edges. + + Returns: + - nx.DiGraph: A directed graph created from the user's input. + + Example user input: + Enter an edge: A B 4 + Enter an edge: B C 2 + Enter an edge: done + """ + # Initialize an empty directed graph + graph = nx.DiGraph() + + # Instructions for the user + print("Enter the graph as a list of edges with time lags. Enter 'done' when you are finished.") + print("Each edge should be entered in the format 'node1 node2 time_lag'. For example: 'A B 4'") + + # Loop to receive user input + while True: + edge = input("Enter an edge: ") + if edge.lower() == "done": + break + edge = edge.split() + if len(edge) != 3: + print("Invalid edge. Please enter an edge in the format 'node1 node2 time_lag'.") + continue + node1, node2, time_lag = edge + try: + time_lag = float(time_lag) + except ValueError: + print("Invalid weight. Please enter a numerical value for the time_lag.") + continue + graph.add_edge(node1, node2, time_lag=time_lag) + + return graph + +def create_graph_from_csv(file_path:str) -> nx.DiGraph: + """ + Creates a directed graph from a CSV file. + + The CSV file should have at least three columns: 'node1', 'node2', and 'time_lag'. + Each row represents an edge from 'node1' to 'node2' with a 'time_lag' attribute. + + Parameters: + - file_path (str): The path to the CSV file. + + Returns: + - nx.DiGraph: A directed graph created from the CSV file. + + Example CSV content: + node1,node2,time_lag + A,B,5 + B,C,2 + A,C,7 + """ + # Read the CSV file into a DataFrame + df = pd.read_csv(file_path) + + # Initialize an empty directed graph + graph = nx.DiGraph() + + # Add edges with time lag to the graph + for index, row in df.iterrows(): + graph.add_edge(row['node1'], row['node2'], time_lag=row['time_lag']) + + return graph \ No newline at end of file From 4d880b5759218d3884f5e96368b0439c1793bac9 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 4 Jul 2024 03:36:30 +0000 Subject: [PATCH 06/67] parents to columns --- dowhy/timeseries/causal_effect_tutorial.ipynb | 4 +-- dowhy/timeseries/timeseries.py | 33 ++++++++++--------- 2 files changed, 19 insertions(+), 18 deletions(-) diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index 3beab3cda..626bebf1e 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -124,7 +124,7 @@ "dataframe=pd.read_csv(dataset_path)\n", "\n", "# the node for which effect estimation has to be done, node:6\n", - "child_node = 6\n", + "child_node = \"6\"\n", "# find the parent nodes of the given node with respective lag times\n", "parents = find_lagged_parent_nodes(graph, child_node)\n", "parents" @@ -424,7 +424,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.14" + "version": "3.1.undefined" } }, "nbformat": 4, diff --git a/dowhy/timeseries/timeseries.py b/dowhy/timeseries/timeseries.py index c136e964b..41a840cec 100644 --- a/dowhy/timeseries/timeseries.py +++ b/dowhy/timeseries/timeseries.py @@ -1,32 +1,33 @@ import networkx as nx import pandas as pd -import matplotlib.pyplot as plt +from dowhy.gcm.util import plot +from typing import List, Tuple -def display_networkx_graph(graph): +def display_networkx_graph(graph:nx.DiGraph): # Draw and display the graph - pos = nx.spring_layout(graph) - nx.draw(graph, pos, with_labels=True) - labels = nx.get_edge_attributes(graph, 'time_lag') - nx.draw_networkx_edge_labels(graph, pos, edge_labels=labels) - plt.show() + plot(graph) -def find_lagged_parent_nodes(graph, node): - parent_nodes = {} +def find_lagged_parent_nodes(graph:nx.DiGraph, node:str) -> Tuple[List[str], List[int]]: + parent_nodes = [] + time_lags = [] for n in graph.predecessors(node): edge_data = graph.get_edge_data(n, node) if 'time_lag' in edge_data: - parent_nodes[str(n)] = edge_data['time_lag'] - return parent_nodes + parent_nodes.append(n) + time_lags.append(edge_data['time_lag']) + return parent_nodes, time_lags # once we have the parent dictionary then we can parse it and shift columns within the dataframe with the appropriate lag -def shift_columns(df:pd.DataFrame, parents:dict) -> pd.DataFrame: - # rename parents to columns and allow lag parameter +def shift_columns(df: pd.DataFrame, columns: List[str], lag: List[int]) -> pd.DataFrame: + if len(columns) != len(lag): + raise ValueError("The size of 'columns' and 'lag' lists must be the same.") + new_df = df.copy() - for column, shift in parents.items(): - column=str(column) + for column, shift in zip(columns, lag): if shift > 0: new_df[column] = new_df[column].shift(shift, axis=0, fill_value=None) - filled_df=new_df.fillna(0) + + filled_df = new_df.fillna(0) return filled_df def filter_columns(df:pd.DataFrame, child_node, parent_nodes) -> pd.DataFrame: From 1330658a569a0a99a2b92712c8a85cf056a64020 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 4 Jul 2024 03:38:08 +0000 Subject: [PATCH 07/67] helper --- dowhy/timeseries/timeseries.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dowhy/timeseries/timeseries.py b/dowhy/timeseries/timeseries.py index 41a840cec..c8aa34be3 100644 --- a/dowhy/timeseries/timeseries.py +++ b/dowhy/timeseries/timeseries.py @@ -30,7 +30,7 @@ def shift_columns(df: pd.DataFrame, columns: List[str], lag: List[int]) -> pd.Da filled_df = new_df.fillna(0) return filled_df -def filter_columns(df:pd.DataFrame, child_node, parent_nodes) -> pd.DataFrame: +def _filter_columns(df:pd.DataFrame, child_node, parent_nodes) -> pd.DataFrame: columns_to_keep = [str(child_node)] + list(parent_nodes.keys()) filtered_df = df[columns_to_keep] return filtered_df From 4daf89f44974def25d81346280511705eaac12af Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 4 Jul 2024 03:40:45 +0000 Subject: [PATCH 08/67] updated deprecated plotter --- dowhy/timeseries/timeseries.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dowhy/timeseries/timeseries.py b/dowhy/timeseries/timeseries.py index c8aa34be3..726845a81 100644 --- a/dowhy/timeseries/timeseries.py +++ b/dowhy/timeseries/timeseries.py @@ -1,6 +1,6 @@ import networkx as nx import pandas as pd -from dowhy.gcm.util import plot +from dowhy.utils.plotting import plot from typing import List, Tuple def display_networkx_graph(graph:nx.DiGraph): From 74f898591267364dc4fd4efa510ba4a170d22546 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 5 Jul 2024 06:35:47 +0000 Subject: [PATCH 09/67] removed plotter --- dowhy/timeseries/causal_effect_tutorial.ipynb | 4 ++-- dowhy/timeseries/timeseries.py | 5 ----- 2 files changed, 2 insertions(+), 7 deletions(-) diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index 626bebf1e..85c8fe290 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -36,7 +36,7 @@ "from dowhy.timeseries.timeseries import create_graph_from_csv\n", "from dowhy.timeseries.timeseries import create_graph_from_user\n", "from dowhy.timeseries.timeseries import display_networkx_graph\n", - "from dowhy.utils.plotting import pretty_print_graph" + "from dowhy.utils.plotting import plot, pretty_print_graph" ] }, { @@ -82,7 +82,7 @@ "# Create the graph from the CSV file\n", "graph = create_graph_from_csv(file_path)\n", "pretty_print_graph(graph)\n", - "display_networkx_graph(graph)" + "plot(graph)" ] }, { diff --git a/dowhy/timeseries/timeseries.py b/dowhy/timeseries/timeseries.py index 726845a81..0951f8c0c 100644 --- a/dowhy/timeseries/timeseries.py +++ b/dowhy/timeseries/timeseries.py @@ -1,12 +1,7 @@ import networkx as nx import pandas as pd -from dowhy.utils.plotting import plot from typing import List, Tuple -def display_networkx_graph(graph:nx.DiGraph): - # Draw and display the graph - plot(graph) - def find_lagged_parent_nodes(graph:nx.DiGraph, node:str) -> Tuple[List[str], List[int]]: parent_nodes = [] time_lags = [] From 801014535424bd36509b62321ec12c440fad7062 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 5 Jul 2024 06:39:37 +0000 Subject: [PATCH 10/67] printing graph: best practices --- dowhy/utils/plotting.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/dowhy/utils/plotting.py b/dowhy/utils/plotting.py index e8a978303..a970bafa2 100644 --- a/dowhy/utils/plotting.py +++ b/dowhy/utils/plotting.py @@ -200,8 +200,16 @@ def _plot_as_pyplot_figure(pygraphviz_graph: Any, figure_size: Optional[Tuple[in if figure_size is not None: plt.rcParams["figure.figsize"] = org_fig_size -def pretty_print_graph(graph): - # Display the entered graph +def pretty_print_graph(graph: nx.DiGraph) -> None: + ''' + Pretty print the graph edges with time lags + + Args: + graph: networkx graph + + Returns: + None + ''' print("\nGraph edges with time lags:") for edge in graph.edges(data=True): print(f"{edge[0]} -> {edge[1]} with time-lagged dependency {edge[2]['time_lag']}") \ No newline at end of file From 9a09e6dd0470bc1e9608723f793dd60d801e2635 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 5 Jul 2024 06:52:27 +0000 Subject: [PATCH 11/67] updated imports --- dowhy/timeseries/causal_effect_tutorial.ipynb | 32 ++++--------------- 1 file changed, 6 insertions(+), 26 deletions(-) diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index 85c8fe290..d727410cd 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -1,16 +1,5 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import networkx as nx\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -20,22 +9,13 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - } - ], + "outputs": [], "source": [ - "from dowhy.timeseries.timeseries import create_graph_from_csv\n", - "from dowhy.timeseries.timeseries import create_graph_from_user\n", - "from dowhy.timeseries.timeseries import display_networkx_graph\n", + "import networkx as nx\n", + "import pandas as pd\n", + "from dowhy.utils.timeseries import create_graph_from_csv,create_graph_from_user\n", "from dowhy.utils.plotting import plot, pretty_print_graph" ] }, @@ -424,7 +404,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.1.undefined" + "version": "3.10.14" } }, "nbformat": 4, From 3fa878613ca45c4385b00c31cdf25160d146a666 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 5 Jul 2024 07:52:11 +0000 Subject: [PATCH 12/67] renamed module --- dowhy/timeseries/{timeseries.py => temporal_shift.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename dowhy/timeseries/{timeseries.py => temporal_shift.py} (100%) diff --git a/dowhy/timeseries/timeseries.py b/dowhy/timeseries/temporal_shift.py similarity index 100% rename from dowhy/timeseries/timeseries.py rename to dowhy/timeseries/temporal_shift.py From e0a4ae3aec3cd31e9f944e2ace1b12b97841cb55 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Tue, 9 Jul 2024 08:46:28 +0000 Subject: [PATCH 13/67] added docstrings --- dowhy/timeseries/causal_effect_tutorial.ipynb | 4 +-- dowhy/timeseries/temporal_shift.py | 36 ++++++++++++++++++- 2 files changed, 37 insertions(+), 3 deletions(-) diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index d727410cd..b52fceac9 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -78,7 +78,7 @@ "metadata": {}, "outputs": [], "source": [ - "from dowhy.timeseries.timeseries import find_lagged_parent_nodes" + "from dowhy.timeseries.temporal_shift import find_lagged_parent_nodes" ] }, { @@ -116,7 +116,7 @@ "metadata": {}, "outputs": [], "source": [ - "from dowhy.timeseries.timeseries import shift_columns,filter_columns" + "from dowhy.timeseries.temporal_shift import shift_columns,_filter_columns" ] }, { diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 0951f8c0c..eef26e480 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -3,6 +3,17 @@ from typing import List, Tuple def find_lagged_parent_nodes(graph:nx.DiGraph, node:str) -> Tuple[List[str], List[int]]: + ''' + Given a graph and a node, this function returns the parent nodes of the node and the time lags associated with the edges between the parent nodes and the node. + + Args: + - graph: the graph object + - node: the node for which we want to find the parent nodes + + Returns: + - parent_nodes: a list of parent nodes of the node + - time_lags: a list of time lags associated with the edges between the parent nodes and the node + ''' parent_nodes = [] time_lags = [] for n in graph.predecessors(node): @@ -14,6 +25,17 @@ def find_lagged_parent_nodes(graph:nx.DiGraph, node:str) -> Tuple[List[str], Lis # once we have the parent dictionary then we can parse it and shift columns within the dataframe with the appropriate lag def shift_columns(df: pd.DataFrame, columns: List[str], lag: List[int]) -> pd.DataFrame: + ''' + Given a dataframe, a list of columns and a list of time lags, this function shifts the columns in the dataframe by the corresponding time lags. + + Args: + - df: the dataframe + - columns: a list of columns to shift + - lag: a list of time lags to shift the columns by + + Returns: + - filled_df: the dataframe with the columns shifted by the corresponding + ''' if len(columns) != len(lag): raise ValueError("The size of 'columns' and 'lag' lists must be the same.") @@ -25,7 +47,19 @@ def shift_columns(df: pd.DataFrame, columns: List[str], lag: List[int]) -> pd.Da filled_df = new_df.fillna(0) return filled_df -def _filter_columns(df:pd.DataFrame, child_node, parent_nodes) -> pd.DataFrame: +def _filter_columns(df:pd.DataFrame, child_node:int, parent_nodes:dict) -> pd.DataFrame: + ''' + Given a dataframe, a child node and a dictionary of parent nodes, this function filters the dataframe to keep only the columns of the child node and the parent nodes. + + Args: + - df: the dataframe + - child_node: the child node + - parent_nodes: a dictionary of parent nodes + + Returns: + - filtered_df: the dataframe with only the columns of the child node and the parent nodes + ''' + columns_to_keep = [str(child_node)] + list(parent_nodes.keys()) filtered_df = df[columns_to_keep] return filtered_df From 979bc32d0f8bfbe6fe962950e4e2487e61f34421 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 12 Jul 2024 06:02:29 +0000 Subject: [PATCH 14/67] moved datasets --- .../source/example_notebooks/datasets}/temporal_dataset.csv | 0 .../source/example_notebooks/datasets}/temporal_graph.csv | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename {dowhy/timeseries => docs/source/example_notebooks/datasets}/temporal_dataset.csv (100%) rename {dowhy/timeseries => docs/source/example_notebooks/datasets}/temporal_graph.csv (100%) diff --git a/dowhy/timeseries/temporal_dataset.csv b/docs/source/example_notebooks/datasets/temporal_dataset.csv similarity index 100% rename from dowhy/timeseries/temporal_dataset.csv rename to docs/source/example_notebooks/datasets/temporal_dataset.csv diff --git a/dowhy/timeseries/temporal_graph.csv b/docs/source/example_notebooks/datasets/temporal_graph.csv similarity index 100% rename from dowhy/timeseries/temporal_graph.csv rename to docs/source/example_notebooks/datasets/temporal_graph.csv From c495ddba3c7f7d92bc855641bb614efca6834fee Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 12 Jul 2024 06:03:18 +0000 Subject: [PATCH 15/67] updated tutorial notebook --- dowhy/timeseries/causal_effect_tutorial.ipynb | 97 ++++++++++--------- dowhy/timeseries/temporal_shift.py | 10 +- 2 files changed, 57 insertions(+), 50 deletions(-) diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index b52fceac9..645263567 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -7,11 +7,27 @@ "## Taking Causal Graph as Input" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Temporal causal inference is a difficult problem to solve due to lagged links existing in the graph. Estimating the lag between the parent and action node is quite challenging. In this notebook, we demonstrate the use of temporal shift to normalise temporal datasets and establish causal effects." + ] + }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], "source": [ "import networkx as nx\n", "import pandas as pd\n", @@ -28,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -46,9 +62,9 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -57,7 +73,7 @@ ], "source": [ "# Prompt user to input the path to the CSV file\n", - "file_path = \"./temporal_graph.csv\"\n", + "file_path = \"../../docs/source/example_notebooks/datasets/temporal_graph.csv\"\n", "\n", "# Create the graph from the CSV file\n", "graph = create_graph_from_csv(file_path)\n", @@ -74,54 +90,45 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "from dowhy.timeseries.temporal_shift import find_lagged_parent_nodes" + "from dowhy.timeseries.temporal_shift import find_lagged_parent_nodes,shift_columns,_filter_columns" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'5': 1, '7': 3}" + "([5, 7], [1, 3])" ] }, - "execution_count": 6, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# read the dataframe in a csv format from the user, and then ask the user to select any 2 rows for \n", - "# the effect estimation usecase\n", - "dataset_path=\"temporal_dataset.csv\"\n", + "# read the dataframe in a csv format from the user\n", + "dataset_path=\"../../docs/source/example_notebooks/datasets/temporal_dataset.csv\"\n", "dataframe=pd.read_csv(dataset_path)\n", "\n", "# the node for which effect estimation has to be done, node:6\n", - "child_node = \"6\"\n", - "# find the parent nodes of the given node with respective lag times\n", - "parents = find_lagged_parent_nodes(graph, child_node)\n", + "target_node = 6\n", + "\n", + "# find the action nodes of the given target node with respective lag times\n", + "parents = find_lagged_parent_nodes(graph, target_node)\n", "parents" ] }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "from dowhy.timeseries.temporal_shift import shift_columns,_filter_columns" - ] - }, - { - "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -218,19 +225,19 @@ "4 0 1 5 7 8.0 9 8.0" ] }, - "execution_count": 8, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "time_shifted_df = shift_columns(dataframe,parents)\n", + "time_shifted_df = shift_columns(dataframe,parents[0],parents[1])\n", "time_shifted_df.head()" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -254,62 +261,62 @@ " \n", " \n", " \n", - " 6\n", " 5\n", " 7\n", + " 6\n", " \n", " \n", " \n", " \n", " 0\n", - " 6\n", " 0.0\n", " 0.0\n", + " 6\n", " \n", " \n", " 1\n", - " 7\n", " 5.0\n", " 0.0\n", + " 7\n", " \n", " \n", " 2\n", - " 8\n", " 6.0\n", " 0.0\n", + " 8\n", " \n", " \n", " 3\n", - " 9\n", " 7.0\n", " 7.0\n", + " 9\n", " \n", " \n", " 4\n", - " 9\n", " 8.0\n", " 8.0\n", + " 9\n", " \n", " \n", "\n", "" ], "text/plain": [ - " 6 5 7\n", - "0 6 0.0 0.0\n", - "1 7 5.0 0.0\n", - "2 8 6.0 0.0\n", - "3 9 7.0 7.0\n", - "4 9 8.0 8.0" + " 5 7 6\n", + "0 0.0 0.0 6\n", + "1 5.0 0.0 7\n", + "2 6.0 0.0 8\n", + "3 7.0 7.0 9\n", + "4 8.0 8.0 9" ] }, - "execution_count": 9, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "filtered_ts_df = filter_columns(time_shifted_df,child_node,parents)\n", + "filtered_ts_df = _filter_columns(time_shifted_df,target_node,parents[0])\n", "filtered_ts_df.head()" ] }, @@ -322,7 +329,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "metadata": {}, "outputs": [ { diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index eef26e480..23086e076 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -42,24 +42,24 @@ def shift_columns(df: pd.DataFrame, columns: List[str], lag: List[int]) -> pd.Da new_df = df.copy() for column, shift in zip(columns, lag): if shift > 0: - new_df[column] = new_df[column].shift(shift, axis=0, fill_value=None) + new_df[str(column)] = new_df[str(column)].shift(shift, axis=0, fill_value=None) filled_df = new_df.fillna(0) return filled_df -def _filter_columns(df:pd.DataFrame, child_node:int, parent_nodes:dict) -> pd.DataFrame: +def _filter_columns(df:pd.DataFrame, child_node:int, parent_nodes:List[int]) -> pd.DataFrame: ''' Given a dataframe, a child node and a dictionary of parent nodes, this function filters the dataframe to keep only the columns of the child node and the parent nodes. Args: - df: the dataframe - child_node: the child node - - parent_nodes: a dictionary of parent nodes + - parent_nodes: a list of parent nodes Returns: - filtered_df: the dataframe with only the columns of the child node and the parent nodes ''' - - columns_to_keep = [str(child_node)] + list(parent_nodes.keys()) + columns_to_keep = [str(node) for node in parent_nodes] + columns_to_keep += [str(child_node)] filtered_df = df[columns_to_keep] return filtered_df From 74ffbdac3c2d1845e676e70cb3a67f6231cd1862 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 12 Jul 2024 06:40:26 +0000 Subject: [PATCH 16/67] improved notebook quality --- dowhy/timeseries/causal_effect_tutorial.ipynb | 313 ++---------------- 1 file changed, 35 insertions(+), 278 deletions(-) diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index 645263567..79a20bc6b 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -4,30 +4,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Taking Causal Graph as Input" + "# Temporal Causal Inference\n", + "\n", + "In this notebook, we will look at an example of causal effect inference for Temporal Dependencies within a Graphical Causal Model. We demonstrate the use of temporal shift to normalise temporal datasets and establish causal effects." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Temporal causal inference is a difficult problem to solve due to lagged links existing in the graph. Estimating the lag between the parent and action node is quite challenging. In this notebook, we demonstrate the use of temporal shift to normalise temporal datasets and establish causal effects." + "Estimating the lag between the parent and action node is quite challenging in temporal causal inference. In this tutorial, we will assume we have the ground truth causal graph as an input." ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - } - ], + "outputs": [], "source": [ "import networkx as nx\n", "import pandas as pd\n", @@ -39,40 +32,24 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "- The user can either create a csv file with the edges in the graph or input the edges manually" + "The user can create a csv file with the edges in the temporal graph. The columns in the csv are node_1, node_2, time_lag which represents an directed edge node_1 -> node_2 with the time lag of time_lag. Let us consider the following graph as the input\n", + "\n", + "| node1 | node2 | time_lag |\n", + "|-------|-------|----------|\n", + "| 1 | 2 | 3 |\n", + "| 2 | 3 | 4 |\n", + "| 5 | 6 | 1 |\n", + "| 4 | 7 | 4 |\n", + "| 7 | 6 | 3 |" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Graph edges with time lags:\n", - "1 -> 2 with time-lagged dependency 3\n", - "2 -> 3 with time-lagged dependency 4\n", - "5 -> 6 with time-lagged dependency 1\n", - "4 -> 7 with time-lagged dependency 4\n", - "7 -> 6 with time-lagged dependency 3\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# Prompt user to input the path to the CSV file\n", + "# Input a csv file with the edges in the graph with the columns: node_1,node_2,time_lag\n", "file_path = \"../../docs/source/example_notebooks/datasets/temporal_graph.csv\"\n", "\n", "# Create the graph from the CSV file\n", @@ -85,12 +62,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Dataset Shifting and Preprocessing" + "## Dataset Shifting and Filtering\n", + "\n", + "In temporal causal inference, accurately estimating causal effects often requires accounting for time lags between nodes in a graph. For instance, if node_1 influences node_2 with a time lag of 5 timestamps, we represent this dependency as node_1(t-5) -> node_2(t). To maintain this causal relationship in our analysis, we need to shift the columns by the given time lag.\n", + "\n", + "When considering node_2 as the target node, the data for node_1 should be shifted down by 5 timestamps. This adjustment ensures that the new edge node_1(t) -> node_2(t) accurately represents the same lagged dependency as before. Shifting the data in this manner aligns the time series data correctly, allowing us to properly analyze and estimate the causal effects." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -99,20 +80,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "([5, 7], [1, 3])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# read the dataframe in a csv format from the user\n", "dataset_path=\"../../docs/source/example_notebooks/datasets/temporal_dataset.csv\"\n", @@ -128,108 +98,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
1234567
012340.060.0
123455.070.0
234566.080.0
345677.097.0
401578.098.0
\n", - "
" - ], - "text/plain": [ - " 1 2 3 4 5 6 7\n", - "0 1 2 3 4 0.0 6 0.0\n", - "1 2 3 4 5 5.0 7 0.0\n", - "2 3 4 5 6 6.0 8 0.0\n", - "3 4 5 6 7 7.0 9 7.0\n", - "4 0 1 5 7 8.0 9 8.0" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "time_shifted_df = shift_columns(dataframe,parents[0],parents[1])\n", "time_shifted_df.head()" @@ -237,84 +108,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
576
00.00.06
15.00.07
26.00.08
37.07.09
48.08.09
\n", - "
" - ], - "text/plain": [ - " 5 7 6\n", - "0 0.0 0.0 6\n", - "1 5.0 0.0 7\n", - "2 6.0 0.0 8\n", - "3 7.0 7.0 9\n", - "4 8.0 8.0 9" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "filtered_ts_df = _filter_columns(time_shifted_df,target_node,parents[0])\n", "filtered_ts_df.head()" @@ -324,60 +120,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Cause Estimation using Dowhy" + "## Cause Estimation using Dowhy\n", + "\n", + "Once you have the new dataframe, causal effect estimation can be performed on the target node with respect to the action nodes." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "*** Causal Estimate ***\n", - "\n", - "## Identified estimand\n", - "Estimand type: EstimandType.NONPARAMETRIC_ATE\n", - "\n", - "### Estimand : 1\n", - "Estimand name: backdoor\n", - "Estimand expression:\n", - " d \n", - "────(E[6])\n", - "d[5] \n", - "Estimand assumption 1, Unconfoundedness: If U→{5} and U→6 then P(6|5,,U) = P(6|5,)\n", - "\n", - "## Realized estimand\n", - "b: 6~5\n", - "Target units: ate\n", - "\n", - "## Estimate\n", - "Mean value: 0.21739130434782616\n", - "p-value: [0.24486798]\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/scipy/stats/_axis_nan_policy.py:531: UserWarning: kurtosistest only valid for n>=20 ... continuing anyway, n=10\n", - " res = hypotest_fun_out(*samples, **kwds)\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n" - ] - } - ], + "outputs": [], "source": [ "# perform causal effect estimation on this new dataset\n", "import dowhy\n", "from dowhy import CausalModel\n", "\n", - "# Assuming 'df' is your DataFrame, 'treatment' is your treatment variable, and 'outcome' is your outcome variable\n", - "# Also assuming 'common_causes' is a list of common cause variables\n", - "\n", "model = CausalModel(\n", " data=filtered_ts_df,\n", " treatment='5',\n", From 49bad7615258d44ad9697b165dc72dca726f67f4 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Mon, 15 Jul 2024 06:17:25 +0000 Subject: [PATCH 17/67] sphinx documentation --- dowhy/timeseries/temporal_shift.py | 59 +++++++++++++++--------------- dowhy/utils/plotting.py | 15 ++++---- dowhy/utils/timeseries.py | 31 +++++++++------- 3 files changed, 54 insertions(+), 51 deletions(-) diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 23086e076..c33eff663 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -3,17 +3,16 @@ from typing import List, Tuple def find_lagged_parent_nodes(graph:nx.DiGraph, node:str) -> Tuple[List[str], List[int]]: - ''' + """ Given a graph and a node, this function returns the parent nodes of the node and the time lags associated with the edges between the parent nodes and the node. - Args: - - graph: the graph object - - node: the node for which we want to find the parent nodes - - Returns: - - parent_nodes: a list of parent nodes of the node - - time_lags: a list of time lags associated with the edges between the parent nodes and the node - ''' + :param graph: The graph object. + :type graph: networkx.Graph + :param node: The node for which we want to find the parent nodes. + :type node: string + :return: A tuple containing a list of parent nodes of the node and a list of time lags associated with the edges between the parent nodes and the node. + :rtype: tuple (list, list) + """ parent_nodes = [] time_lags = [] for n in graph.predecessors(node): @@ -25,17 +24,18 @@ def find_lagged_parent_nodes(graph:nx.DiGraph, node:str) -> Tuple[List[str], Lis # once we have the parent dictionary then we can parse it and shift columns within the dataframe with the appropriate lag def shift_columns(df: pd.DataFrame, columns: List[str], lag: List[int]) -> pd.DataFrame: - ''' - Given a dataframe, a list of columns and a list of time lags, this function shifts the columns in the dataframe by the corresponding time lags. - - Args: - - df: the dataframe - - columns: a list of columns to shift - - lag: a list of time lags to shift the columns by + """ + Given a dataframe, a list of columns, and a list of time lags, this function shifts the columns in the dataframe by the corresponding time lags. - Returns: - - filled_df: the dataframe with the columns shifted by the corresponding - ''' + :param df: The dataframe to shift. + :type df: pandas.DataFrame + :param columns: A list of columns to shift. + :type columns: list + :param lags: A list of time lags to shift the columns by. + :type lags: list + :return: The dataframe with the columns shifted by the corresponding time lags. + :rtype: pandas.DataFrame + """ if len(columns) != len(lag): raise ValueError("The size of 'columns' and 'lag' lists must be the same.") @@ -48,17 +48,18 @@ def shift_columns(df: pd.DataFrame, columns: List[str], lag: List[int]) -> pd.Da return filled_df def _filter_columns(df:pd.DataFrame, child_node:int, parent_nodes:List[int]) -> pd.DataFrame: - ''' - Given a dataframe, a child node and a dictionary of parent nodes, this function filters the dataframe to keep only the columns of the child node and the parent nodes. - - Args: - - df: the dataframe - - child_node: the child node - - parent_nodes: a list of parent nodes + """ + Given a dataframe, a target node and a list of action/parent nodes, this function filters the dataframe to keep only the columns of the target node and the action/parent nodes. - Returns: - - filtered_df: the dataframe with only the columns of the child node and the parent nodes - ''' + :param df: The dataframe to filter. + :type df: pandas.DataFrame + :param child_node: The child node. + :type child_node: str + :param parent_nodes: A list of parent nodes. + :type parent_nodes: list + :return: The dataframe with only the columns of the child node and the parent nodes. + :rtype: pandas.DataFrame + """ columns_to_keep = [str(node) for node in parent_nodes] columns_to_keep += [str(child_node)] filtered_df = df[columns_to_keep] diff --git a/dowhy/utils/plotting.py b/dowhy/utils/plotting.py index a970bafa2..f71de34e9 100644 --- a/dowhy/utils/plotting.py +++ b/dowhy/utils/plotting.py @@ -201,15 +201,14 @@ def _plot_as_pyplot_figure(pygraphviz_graph: Any, figure_size: Optional[Tuple[in plt.rcParams["figure.figsize"] = org_fig_size def pretty_print_graph(graph: nx.DiGraph) -> None: - ''' - Pretty print the graph edges with time lags - - Args: - graph: networkx graph + """ + Pretty print the graph edges with time lags. - Returns: - None - ''' + :param graph: The networkx graph. + :type graph: networkx.Graph + :return: None + :rtype: None + """ print("\nGraph edges with time lags:") for edge in graph.edges(data=True): print(f"{edge[0]} -> {edge[1]} with time-lagged dependency {edge[2]['time_lag']}") \ No newline at end of file diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py index 0e729c5b6..1c5348c85 100644 --- a/dowhy/utils/timeseries.py +++ b/dowhy/utils/timeseries.py @@ -9,13 +9,13 @@ def create_graph_from_user() -> nx.DiGraph: where 'node1' and 'node2' are the nodes connected by the edge, and 'time_lag' is a numerical value representing the weight of the edge. The user should enter 'done' to finish inputting edges. - Returns: - - nx.DiGraph: A directed graph created from the user's input. + :return: A directed graph created from the user's input. + :rtype: nx.DiGraph Example user input: - Enter an edge: A B 4 - Enter an edge: B C 2 - Enter an edge: done + Enter an edge: A B 4 + Enter an edge: B C 2 + Enter an edge: done """ # Initialize an empty directed graph graph = nx.DiGraph() @@ -50,17 +50,20 @@ def create_graph_from_csv(file_path:str) -> nx.DiGraph: The CSV file should have at least three columns: 'node1', 'node2', and 'time_lag'. Each row represents an edge from 'node1' to 'node2' with a 'time_lag' attribute. - Parameters: - - file_path (str): The path to the CSV file. + :param file_path: The path to the CSV file. + :type file_path: str + :return: A directed graph created from the CSV file. + :rtype: nx.DiGraph - Returns: - - nx.DiGraph: A directed graph created from the CSV file. + Example: + Example CSV content: + + .. code-block:: csv - Example CSV content: - node1,node2,time_lag - A,B,5 - B,C,2 - A,C,7 + node1,node2,time_lag + A,B,5 + B,C,2 + A,C,7 """ # Read the CSV file into a DataFrame df = pd.read_csv(file_path) From fbfd7d28fdcd5ad30e403a7707f714aa97fdd1b5 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Mon, 15 Jul 2024 06:19:44 +0000 Subject: [PATCH 18/67] removed pretty print --- dowhy/timeseries/causal_effect_tutorial.ipynb | 1 - 1 file changed, 1 deletion(-) diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index 79a20bc6b..15feb36ec 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -54,7 +54,6 @@ "\n", "# Create the graph from the CSV file\n", "graph = create_graph_from_csv(file_path)\n", - "pretty_print_graph(graph)\n", "plot(graph)" ] }, From 348391e7a4977ab01507b13cd708bcf25e7a38a2 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Mon, 15 Jul 2024 06:56:07 +0000 Subject: [PATCH 19/67] dot format --- dowhy/utils/timeseries.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py index 1c5348c85..bc8c7533a 100644 --- a/dowhy/utils/timeseries.py +++ b/dowhy/utils/timeseries.py @@ -75,4 +75,21 @@ def create_graph_from_csv(file_path:str) -> nx.DiGraph: for index, row in df.iterrows(): graph.add_edge(row['node1'], row['node2'], time_lag=row['time_lag']) + return graph + +def create_graph_from_dot_format(file_path:str) -> nx.DiGraph: + """ + Creates a directed graph from a DOT file. + + The DOT file should contain a graph in DOT format. + + :param file_path: The path to the DOT file. + :type file_path: str + :return: A directed graph created from the DOT file. + :rtype: nx.DiGraph + """ + + # Read the DOT file into a graph + graph = nx.drawing.nx_agraph.read_dot(file_path) + return graph \ No newline at end of file From f6df32a718060d6f1fff2fbb0e4e67ba973f5318 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Tue, 16 Jul 2024 15:44:31 +0000 Subject: [PATCH 20/67] better node names --- .../datasets/temporal_dataset.csv | 2 +- .../datasets/temporal_graph.csv | 10 +++++----- dowhy/timeseries/causal_effect_tutorial.ipynb | 20 +++++++++---------- 3 files changed, 16 insertions(+), 16 deletions(-) diff --git a/docs/source/example_notebooks/datasets/temporal_dataset.csv b/docs/source/example_notebooks/datasets/temporal_dataset.csv index ef85d5703..f58cf5796 100644 --- a/docs/source/example_notebooks/datasets/temporal_dataset.csv +++ b/docs/source/example_notebooks/datasets/temporal_dataset.csv @@ -1,4 +1,4 @@ -1,2,3,4,5,6,7 +V1,V2,V3,V4,V5,V6,V7 1,2,3,4,5,6,7 2,3,4,5,6,7,8 3,4,5,6,7,8,9 diff --git a/docs/source/example_notebooks/datasets/temporal_graph.csv b/docs/source/example_notebooks/datasets/temporal_graph.csv index 2bb1c860f..35cb047ed 100644 --- a/docs/source/example_notebooks/datasets/temporal_graph.csv +++ b/docs/source/example_notebooks/datasets/temporal_graph.csv @@ -1,6 +1,6 @@ node1,node2,time_lag -1,2,3 -2,3,4 -5,6,1 -4,7,4 -7,6,3 \ No newline at end of file +V1,V2,3 +V2,V3,4 +V5,V6,1 +V4,V7,4 +V7,V6,3 \ No newline at end of file diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index 15feb36ec..a83bc143e 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -34,13 +34,13 @@ "source": [ "The user can create a csv file with the edges in the temporal graph. The columns in the csv are node_1, node_2, time_lag which represents an directed edge node_1 -> node_2 with the time lag of time_lag. Let us consider the following graph as the input\n", "\n", - "| node1 | node2 | time_lag |\n", - "|-------|-------|----------|\n", - "| 1 | 2 | 3 |\n", - "| 2 | 3 | 4 |\n", - "| 5 | 6 | 1 |\n", - "| 4 | 7 | 4 |\n", - "| 7 | 6 | 3 |" + "| node1 | node2 | time_lag |\n", + "|--------|--------|----------|\n", + "| V1 | V2 | 3 |\n", + "| V2 | V3 | 4 |\n", + "| V5 | V6 | 1 |\n", + "| V4 | V7 | 4 |\n", + "| V7 | V6 | 3 |" ] }, { @@ -88,7 +88,7 @@ "dataframe=pd.read_csv(dataset_path)\n", "\n", "# the node for which effect estimation has to be done, node:6\n", - "target_node = 6\n", + "target_node = 'V6'\n", "\n", "# find the action nodes of the given target node with respective lag times\n", "parents = find_lagged_parent_nodes(graph, target_node)\n", @@ -136,8 +136,8 @@ "\n", "model = CausalModel(\n", " data=filtered_ts_df,\n", - " treatment='5',\n", - " outcome='6',\n", + " treatment='V5',\n", + " outcome='V6',\n", " proceed_when_unidentifiable=True # Proceed even if the causal graph is not fully identifiable\n", ")\n", "\n", From 2bf8c3d78f6425a2778699fd20d5c9ffb45c6577 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Mon, 22 Jul 2024 03:24:31 +0000 Subject: [PATCH 21/67] edge validation --- dowhy/timeseries/causal_effect_tutorial.ipynb | 28 ++++++++++++++++--- dowhy/utils/timeseries.py | 6 ++++ 2 files changed, 30 insertions(+), 4 deletions(-) diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index a83bc143e..00c89c96f 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -18,9 +18,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], "source": [ "import networkx as nx\n", "import pandas as pd\n", @@ -45,9 +54,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Input a csv file with the edges in the graph with the columns: node_1,node_2,time_lag\n", "file_path = \"../../docs/source/example_notebooks/datasets/temporal_graph.csv\"\n", diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py index bc8c7533a..7acd10e88 100644 --- a/dowhy/utils/timeseries.py +++ b/dowhy/utils/timeseries.py @@ -73,6 +73,12 @@ def create_graph_from_csv(file_path:str) -> nx.DiGraph: # Add edges with time lag to the graph for index, row in df.iterrows(): + # add validation for the time lag column to be a number + try: + row['time_lag'] = float(row['time_lag']) + except ValueError: + print("Invalid weight. Please enter a numerical value for the time_lag for the edge between {} and {}.".format(row['node1'], row['node2'])) + return None graph.add_edge(row['node1'], row['node2'], time_lag=row['time_lag']) return graph From eaba762b719700cf61dbe2cc75bf2fd216ad2d4d Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 25 Jul 2024 08:21:23 +0000 Subject: [PATCH 22/67] updated shifting columns with 0,1,..,max_lag --- dowhy/timeseries/causal_effect_tutorial.ipynb | 293 +++++++++++++++++- dowhy/timeseries/temporal_shift.py | 34 +- 2 files changed, 302 insertions(+), 25 deletions(-) diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index 00c89c96f..b401d8d59 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -54,12 +54,12 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -99,9 +99,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(['V5', 'V7'], [1.0, 3.0])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# read the dataframe in a csv format from the user\n", "dataset_path=\"../../docs/source/example_notebooks/datasets/temporal_dataset.csv\"\n", @@ -117,9 +128,132 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
V1V2V3V4V5V6V7V5_lag1V7_lag1V7_lag2V7_lag3
012345670000
123456785700
234567896870
3456789107987
4015789781098
\n", + "
" + ], + "text/plain": [ + " V1 V2 V3 V4 V5 V6 V7 V5_lag1 V7_lag1 V7_lag2 V7_lag3\n", + "0 1 2 3 4 5 6 7 0 0 0 0\n", + "1 2 3 4 5 6 7 8 5 7 0 0\n", + "2 3 4 5 6 7 8 9 6 8 7 0\n", + "3 4 5 6 7 8 9 10 7 9 8 7\n", + "4 0 1 5 7 8 9 7 8 10 9 8" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "time_shifted_df = shift_columns(dataframe,parents[0],parents[1])\n", "time_shifted_df.head()" @@ -127,9 +261,108 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
V6V5V5_lag1V7V7_lag1V7_lag2V7_lag3
06507000
17658700
28769870
398710987
498871098
\n", + "
" + ], + "text/plain": [ + " V6 V5 V5_lag1 V7 V7_lag1 V7_lag2 V7_lag3\n", + "0 6 5 0 7 0 0 0\n", + "1 7 6 5 8 7 0 0\n", + "2 8 7 6 9 8 7 0\n", + "3 9 8 7 10 9 8 7\n", + "4 9 8 8 7 10 9 8" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "filtered_ts_df = _filter_columns(time_shifted_df,target_node,parents[0])\n", "filtered_ts_df.head()" @@ -146,9 +379,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*** Causal Estimate ***\n", + "\n", + "## Identified estimand\n", + "Estimand type: EstimandType.NONPARAMETRIC_ATE\n", + "\n", + "### Estimand : 1\n", + "Estimand name: backdoor\n", + "Estimand expression:\n", + " d \n", + "─────(E[V₆])\n", + "d[V₅] \n", + "Estimand assumption 1, Unconfoundedness: If U→{V5} and U→V6 then P(V6|V5,,U) = P(V6|V5,)\n", + "\n", + "## Realized estimand\n", + "b: V6~V5\n", + "Target units: ate\n", + "\n", + "## Estimate\n", + "Mean value: 0.39256198347107585\n", + "p-value: [0.04856244]\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/scipy/stats/_axis_nan_policy.py:531: UserWarning: kurtosistest only valid for n>=20 ... continuing anyway, n=10\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n" + ] + } + ], "source": [ "# perform causal effect estimation on this new dataset\n", "import dowhy\n", diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index c33eff663..77640aff5 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -22,10 +22,9 @@ def find_lagged_parent_nodes(graph:nx.DiGraph, node:str) -> Tuple[List[str], Lis time_lags.append(edge_data['time_lag']) return parent_nodes, time_lags -# once we have the parent dictionary then we can parse it and shift columns within the dataframe with the appropriate lag def shift_columns(df: pd.DataFrame, columns: List[str], lag: List[int]) -> pd.DataFrame: """ - Given a dataframe, a list of columns, and a list of time lags, this function shifts the columns in the dataframe by the corresponding time lags. + Given a dataframe, a list of columns, and a list of time lags, this function shifts the columns in the dataframe by the corresponding time lags, creating a new unique column for each shifted version. :param df: The dataframe to shift. :type df: pandas.DataFrame @@ -40,27 +39,34 @@ def shift_columns(df: pd.DataFrame, columns: List[str], lag: List[int]) -> pd.Da raise ValueError("The size of 'columns' and 'lag' lists must be the same.") new_df = df.copy() - for column, shift in zip(columns, lag): - if shift > 0: - new_df[str(column)] = new_df[str(column)].shift(shift, axis=0, fill_value=None) + for column, max_lag in zip(columns, lag): + max_lag = int(max_lag) + for shift in range(1, max_lag + 1): + new_column_name = f"{column}_lag{shift}" + new_df[new_column_name] = new_df[column].shift(shift, axis=0, fill_value=0) - filled_df = new_df.fillna(0) - return filled_df + return new_df -def _filter_columns(df:pd.DataFrame, child_node:int, parent_nodes:List[int]) -> pd.DataFrame: +def _filter_columns(df: pd.DataFrame, child_node: int, parent_nodes: List[int]) -> pd.DataFrame: """ - Given a dataframe, a target node and a list of action/parent nodes, this function filters the dataframe to keep only the columns of the target node and the action/parent nodes. + Given a dataframe, a target node, and a list of action/parent nodes, this function filters the dataframe to keep only the columns of the target node, the parent nodes, and their shifted versions. :param df: The dataframe to filter. :type df: pandas.DataFrame :param child_node: The child node. - :type child_node: str + :type child_node: int :param parent_nodes: A list of parent nodes. :type parent_nodes: list - :return: The dataframe with only the columns of the child node and the parent nodes. + :return: The dataframe with only the columns of the child node, parent nodes, and their shifted versions. :rtype: pandas.DataFrame """ - columns_to_keep = [str(node) for node in parent_nodes] - columns_to_keep += [str(child_node)] + columns_to_keep = [str(child_node)] + for node in parent_nodes: + columns_to_keep.append(str(node)) + # Include all shifted versions of the parent node + shifted_columns = [col for col in df.columns if col.startswith(f"{node}_lag")] + columns_to_keep.extend(shifted_columns) + + # Filter the dataframe to keep only the relevant columns filtered_df = df[columns_to_keep] - return filtered_df + return filtered_df \ No newline at end of file From 01c275fa39b21adc53ffa08aaca0d1ea3942fad6 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 25 Jul 2024 08:49:28 +0000 Subject: [PATCH 23/67] support for dot format --- .../datasets/temporal_graph.dot | 7 + dowhy/timeseries/causal_effect_tutorial.ipynb | 331 ++---------------- dowhy/utils/timeseries.py | 35 +- 3 files changed, 63 insertions(+), 310 deletions(-) create mode 100644 docs/source/example_notebooks/datasets/temporal_graph.dot diff --git a/docs/source/example_notebooks/datasets/temporal_graph.dot b/docs/source/example_notebooks/datasets/temporal_graph.dot new file mode 100644 index 000000000..a7fe9272e --- /dev/null +++ b/docs/source/example_notebooks/datasets/temporal_graph.dot @@ -0,0 +1,7 @@ +digraph G { + V1 -> V2 [label=3]; + V2 -> V3 [label=4]; + V5 -> V6 [label=1]; + V4 -> V7 [label=4]; + V7 -> V6 [label=3]; +} \ No newline at end of file diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index b401d8d59..652183b5a 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -18,18 +18,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - } - ], + "outputs": [], "source": [ "import networkx as nx\n", "import pandas as pd\n", @@ -54,20 +45,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGVCAYAAAAyrrwGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABUBElEQVR4nO3dd5xd533f+c9zzrl9+gwGhSgkSIAEwAqCFSApih0YSmIkWZLXkmOvvY4T29ls4hJ51866RLZjx5vsvmxvso43jh2reC1bHAAskljBAggk2NAJkACJMpg+t517yrN/nHsvBsNBuYNz57bf+0VYxtQHM8+53/P8nuc8j9Jaa4QQQogQGbVugBBCiOYj4SKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkIIIUIn4SKEECJ0Ei5CCCFCJ+EihBAidFatG3AhBU8zXvBwfI3ng6c1hgJTKSxD0RE1SFqSj6I6XF8zbnsUfI2rwfM1SoGlFKYB7RGTlKVQStW6qULUnboJF8fXjOQ9RvIuw3mPU1mX8YKH54MPoEGjUSiK/2EqaIsYLEpa9MUteuMmfXGThASOqJDra0Ztr9gHg/43aru4pf4HlLbhU0qV+1/CMliUMOlLlPqfJYEjBKBquXGl1prTOY/9Y3kOTTgUfI1fuoBRWEZwl6iKYVL+PEDrYCTjas5+jlJYCpamIqztibGiLYJpyEUuzm8k77JvzObAeAHb03iX2P/Q4Glw9Sc/pz9hsa4nxsqOKBHpf6JF1SRcCp7m/ckCe8dsTmddXK2JKEXEUJiKOd31aa3xCe5AC75GKUVn1GBdd4zVXTHaIjKaEQHP1xydctg7lufjjIvjayyliF5G/4PgJscp9j8IRtVrumNc1xWjK2aG+U8Qou7Na7i4vmbPcJ63R/NknKDYEDcNrMu4oC/0vWxP46OJmYqrO6Pc2Z8kJSHTsnyteW/U5s3hPJOOj9aamGEQMcLvf57W5ZFQxFCsaI9w18KkhIxoGfMWLkM5l+dPZDiddTGVImYqzHmoS2utsYt3kx0Rg42Lk1zTEZWaeIsZtz1eOJHheMYBrUiYal5KploHfc/2NUnL4I7+BOt6YhjS/0STq3q4uL7mjeE8bw7nsD1N0jSwalCH9rUm62kUsKozysZFMoppBb7WvDtqs3MoR871iZtGTeZBdLH/aTTL2iLctzgloxjR1KoaLtNHK5ZSxM3ar6IpeJq875dHMas6YzVtj6ie6aMVhSJZB/3P8TU5zydpGdzen+CGnljN2yRENVQtXI6lHZ45nibr+jUbrZxPaRRjKLijP8H6vrhc4E1mKOey/ViaiYJHokajlfMpjWIAbuiJsWlxUspkoulUJVzenyjwg4/T2J6mzTLq9oU75/r4wPq+OHcuTNRtO0VlTmQcnjqeJu34tFlG3b5w255Pwdes6Y5x/5KULJsXTSX0hyiPTBb4/sdpHJ+6DhYIHoDLez67z+QBJGCawKlsMGLJuj7tdd7/YqaBQrNvzEYDD1yRqtsgFKJSoc5oH087fP+jNI6nSdVBfftSxE0Dy6C46CBf6+aIyzCcc9l+bIqs69f9jU1J1FTEDIP9YzYvn8xSw2eahQhVaOEyZns8czwohaUa5MIuiZsGBvDa6RwHx+1aN0fMQc712T6tFNZI/S9qBg9wvj1qs2dEbnBEcwglXHyteeFEpqHuGGdKWAY+sONUlrTjX/TjRf3QWrPjVJYx22u4G5uSWPEGZ9dQjuGcW+vmCHHZQgmXd0ZtPko7xM3GvLBLkqZiyvF5+WRGyhMN5OiUw8HxAjFDNfScRcJU2J7mhZNZPF/6n2hslx0uY7bHztM5VHFvsEZmKEXcMHh/0uHQRKHWzRGXIOf6vHQyi6c1MbOxH4pVSpEwDU5kHN6S8phocJd1NZbKYXnPJ2k2drCURE2FRspjjaBUDpsoBOWwZmAZwbZIPzoj5THR2C7ritw3ZvNRpvHLYTOVymOvnc7WuiniAo6lm6McNlOpPPaSrB4TDWzO4aK15p1RGzQNXw6byShuv/7+ZIHJglfr5ojzeHfUbopy2ExKKeKmwcmsy+mc9D/RmOZ8VX6ccRnJe013YZfEDEXB0xwcl7mXejRuexxPO0Sb7MamxFLBtv37xmTuRTSmOSfDvjEbX2us5ry2USootbw3ZuPKyp26s3/cxvF104ZLcKqq4tBEgawrc3+i8cwpXKYcjyNTBSJGYzyFP1dxQzFV8Plgyql1U8Q0jh9smWKq5u5/seLcyyEZPYsGNKdwOTBWoOBpYk1611hiGgqNZq+UJurK+xMF0o5PrElWKJ6PoRQKxbtjeXyZ2BcNZk7hcmiygKK57xpLoobiRMaVZcl15MhkcCc/HyeZ1lrcVIzbPkMysS8aTMXhkvd8Jm2PVjnEMWIoXA3DeXnmoB5orTmdc1siWABMFTxPNiL9TzSYiiNiJO/harBa5OI2lEJrzWhe7hzDNjo6yttvv83ExMQlf86k45P3dF0dPldNperAiPQ/0WAqPs9lJO/hax3qQ2u/97UBDuzawYJlV/IHz7x5zvuGjh3lVx9ZD8ATv/Tr7H31eQ7s2vGJr7Fq/R18/a+fCq1NM52Rp6VDpbVm+/btZDIZXn/9da655hrWr19PZ2fnBT9vJO/h+ppYyMsUK+mDn/n5f8XxA+/yvT/5d+zftYNcepL27j5Wrb+Df/rHfxFquwAUilNZ6X+isVQ8cimVh8Kcb9n0xI8DcOb4Bxx647Vz3vfKk98Ovp9hsPGzXyq/fcGyK1l544bynyXXXBdae2YyleJUzpOnpUPk+z6ZTIZ0Os3U1BQHDhzg29/+Ns8999wFRzLDxTv4sJ/Ir6QPHtz9Kr/z5Yf50TPfw3MKXHHNdUTjCd78wbZQ21RiGTBW8Ch40v9E46h45HI664V+YW94+DP81e/8CnY2wyvf+xar1t9Zft+r3wsu7DW330PvkmXlt3/m53+5/IJQbZZS5FyfjKtpi7RGOWa+aK2xbZt8Pk88HufAgQMcPnz4vCOZao0gL7UP9ixeyh/97Bco5HPc+fgX+anf+g9E4wkAcpmpqrTNUgrb14zaHouSoR8eK0RVVDRy8XzNpOMR9grQeKqNDQ9/BoBdT/09TiE4sOvwmzsZOnYEgI1PfOWcz/mb3/s6P3vjQn7loZv5f3/jf2ZieCjcRk1jGuBqmJCtYKrCNE2SySS2bTM6OnrBkcyo7VVlMv9S++DxA+9y8sjB4JO05l9vvo1/ettyfv8ff4bTH7wfervg7KS+9D/RSCoKF1dr0FCNe/fSKCQzMc5bzz8NwKvFckSirZ1bH3q8/LHReILu/sW09/Rx5qMPeeE7/5Xf/crD2NlMFVpW/Pdq5En9KlFKkUwm6enpuWjIuL6uSv+DS+uDp44eLn/8a4N/SzSeBGD/6y/x+197nOGPj4XerlIJWvqfaCQVjbG9IFswqnB5X3vbRhYsXcGZjz7kle99i5vvf4yd278LwIZHPkcsEVzEX/m1f8uSa64lEo2hteb/+z9+m63/6Y8589GH7P7+IHd/5ksX+jZzogCNplTy3rVrF++88w6+L8++zJXWmuHhYTzPK///09+ntSadTpNOp1FKMTQ0xGuvvUbiwZ8glkhVpU2X0gc972xZ7p7Pf5Wf/p3/yJmPPuTXHr2VfDbNy9/973zuF36tKu2TKRfRSCoaufjFcKnGraNSirs/+2UA3n7xWV75h2+SHh8FYNO0ktiKtTcSicbKn3Pnli+U3zd68qPwGzaNr4MXvr179+K6Lr7vy5/L+HM+SikMw8A0TSD4mXueh+/72AWHaq2Cv5Q+2N2/pPzxV91wCwALlq6gvbsPoCojFwguORm4iEZS0cjFVGdLRNWw8XNf4Xt/8gd4jsPffOPrAPQvX8nqW+8CYHLkDK8++W3u/eLXSKTaAcp3lgC9VyyvTsOKTBW8AN11113s27dPRi6XQWvNxMREeZRiWWe7ou/7eJ6H53nBBo6WhWmaWJZFNBmnmov2LtYHV964nkRbO7n0FB+8uwe+FATK1Fgw8lq4YmVV2qUh9LlOIaqpwnBR5RJRNYYvC5auYPWGuzmwawf5bBoILvaSQj7HN3//f+U7f/Rv6F++EjuXYfTkxwAsufpaNkyblwlT8K9V5Ynk1atXs3r16qp8r1bheR5//ud/ztTUFJ7n0dXVheu6ZLNZXNfFNE3a29uJx+MkEgluuukm1qxZw1+/nyFXxV2CL9YHo/EEn/1nv8Y3f//XefFv/5JDb7zG+JlT+J5HZ99C7vuxf1y1tpkt8uCoaA4VhYtlBHfu1dxEb9MTP15+SHLmsy3t3b0M/Ny/5L1XnmPo2FEcO8/ilau55YHNbP4f/zmRWLwqbdIalKJltryZb1prJicnKRQKGIZBW1vbJ0IlEokAwe+gOss2zrpQHwR45B//UxJt7Tzzl3/K6Q+P0N7Tyy33P8YX/pffoKOnL/T2aB3czkn/E41E6QqfDPzO+xOcznq0tVBPtz0fDfzktV0kmuSs9lqbPnKxbRvDMEgmk+cNlZJnjqc5MG7THjFr1PL55/gax9d88eoOFiTkORfRGCruqQuTVsttReFq6IoZEixVcLGRykx9cZMDBHfzrbArNwQnUkYMRU+sdQJVNL6Kw6U3dnYFT6tc3L7WLJI7xlAZhkFPTw/AJYVKSW/cDEqzQKu81Lo+9KdMmXMRDaXycIlbGErhaZr2iOPpSlXDPgmXUCmlePzxxxkeHqa/v/+ioVLSF7eC8+V9MFskXTSahbLti2gwFdd5euMmEaP4tH4L8AleCHulJBG6WCzGFVdcccnBApC0FEnLaJn+V7q5kf4nGk3F4RLUfq2W2YrC8TURI6j1i9pTSrE4ZbVMuDg6WILcl5D+JxrLnGaor+2KoqHpz/XWWlPwNSvbo8RlMr9urOqIYijVEjc4tufTn7Bk5CIazpxeMVd1RklYBnaTb3bk6uDB0TXdsVo3RUyzvD1CV9Qg3+T9zyvevF3fHWuZxTOiecwpXOKWwerOKE5x645mZXs+vXGTK1IymVpPDKVY1xNDo5t69Gx7mraIwcqOaK2bIkTF5lzrWdMdI2IonCbdXssvPhW9Tu4a69LqzhgxU1Fo0tKY1hpPa67rihGVTcVEA5pzuPTFTRYnLewm3bzR9jQJy2BVp9w11qNUxOCaziiO35yj54KvsQzFdVKSFQ1qzuGilOKm3jimUthecwWMpzWu1qzrjslEfh27vidOxFBNN/fia43ta1Z2ROmWiXzRoC7rlfPK9giruqLYfvPUvrXWZN1gruXWBYlaN0dcQH/C4pa+OK7WeE1UHst6mvaIwcZFyVo3RYg5u6xwUUqxcVGSzqhJporboM8nu1iOuG9JSmrdDWD9ggT9CYus5zdFeazgBcc4370o2VKbw4rmc9m9N2kZbFqUbIrymKeD3Wdv7IlxRerSnxoXtRMp3gg0Q3nM15q873N1R4TVMtcnGlwot0YrOyKsbvDy2PRy2G39Uo5oJIuSZ8tjjfpgpda6XA7btDglKxRFwwslXErlsZ6YSdr1Gy5gtNZkPE3MVHxKymENaf2CBEtSEbKeX374sJHkPI2p4J7FKSmHiaYQWi9OWAZbVrTTGQ0CplHq38GIRWMpeOCKNpZIOawhRQzFo8va6E9YZBrsBifnBofRbVyU5Boph4kmEeotUnfMZPPyNtojBlMNcIGXgsUw4FNLUlwtF3ZDS0UMNi9vK4+gG2EEk3N9fOCO/gQ39MgzLaJ5VHzM8aU4k3PZdizNRMGjzTIw6rB+rLUm4/pEiqWwa7vkwm4WEwWPbR+mOZN3SZlGXR6ypbUmV1yAcOfCBLf0xWWeRTSVqoQLwJjtsfXDKUZtj7hh1NU8hutrsp5PwlQ8sLRN9m5qQhnHZ9uxKU5mXaKGImaounnx9oqLRyJGMFd5Q2+81k0SInRVCxeArOOz41SWgxMFtNYkazyKKd0telqzOGlx35IUC+SEyaZlez67hnK8M2rj+kH/M2vc/2w/WO7eGze5d3GKpW0yxyeaU1XDBYIL6v1Jhx2nskwUajeKKY1WYqbi1gUJbumN12W5RITvo7TDiyczDOe9mo1iSqMVy1Dc0BPjtv4EMVNWhYnmVfVwKZk+ivG1JmYaRBRVv8hdX5P3NBoZrbSy6aMYx9fEDEV0HkLG00H/87WMVkRrmbdwgWAUc3TKYc9wnlM5F8/XWEoRM1Wo5bLSCZIFX6OUoitqcENPnOt7YjJaaXEfpR3eHM7zUcbB9TWmUsSr0P8cn/KO4e0Rg7U9cW7qjcloRbSMeQ2XEq01QzmP/eM2B8cL5D0fpRQRFZz8aFY4otFa4wOeD44O7hIjhmJZW4S13TGWt0dqWmsX9Wc0H/S//eM2meKhRBFDYc2h/0GwdYvrE+wSUOx/ixIW63piXNURJSI3NaLF1CRcpsu5PocmCuwftxmzPVyf8vMxBgrTCP63+B+a4P9oNJ4+exSsUgpLBc86rOqMcl1XjC7ZrlxcRMHTvD9ZYN+YzXDexZnW/xQKa0b/A9Cz9D8Ay1AkTMXKjihrumP0xc26WaEmxHyrebhMZ3s+I3mv+MflVM5jouAVL+azVPFPMmKwMGHRFzfpjZv0xS2SVv0sORWNxfF1ue+N2B6nsy5jtoevwfN8srkslmmRSMRRQMwyWJgwWRC36C32wfaIIf1PCOosXGbj+MFmhKW7RGNa6Ww+JmRFa3OLS4f/+m++yemhMyg0P/bFL7DsiiXS/4S4gLpfNhUxlNSrRc1YhmJ0+AwTQyfxs1kMw+C9N3dzzfKltW6aEHVNlq4IcRG7d+/G94PNWH3f58SJEwwNDdW6WULUNQkXIS5gaGiI48eP4zgOEKxM9DyP3bt317hlQtQ3CRchLmD37t14nofneRhGcLnkcjmOHz8uoxchLkDCRYjzKI1aMpkMSgWT94ZhUCgUZPQixEVIuAhxHqVRS6FQIBKJnBMw2WxWRi9CXICEixCzmD5qMQwD0wweyFVKkUgksG1bRi9CXICEixCzmD5qSSaT5zzPEo1GZfQixEVIuAgxw8xRSyx27imlSimSyaSMXoS4AAkXIWaYPmpRSpHJZMqT+J7nkclkykuTZfQixOwkXISYprTM2LZtLMtCKYXruuWHKEvPuXieh2VZeJ6H7/scPHiw1k0Xoq7U/fYvQsynSCRCZ2cnAMlksvz2qakpbNsGoKOjozzBX9Lb2zt/jRSiAdT9xpVCzDff9xkbGzvnba+++irHjh0DYPPmzbS3t5ffF4/HSaVS89pGIeqdjFyEmMEwjE+MRJLJJJYVXC7d3d3l0Y0QYnYy5yKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkIIIUIn4SKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkIIIUIn4SKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkIIIUIn4SKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkIIIUIn4SKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkIIIUIn4SKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkIIIUIn4SKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkIIIUIn4SKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkIIIUIn4SKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkIIIUIn4SKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkIIIUIn4SKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkIIIUIn4SKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkIIIUIn4SKEECJ0Ei5CCCFCJ+EihBAidBIuQgghQifhIoQQInQSLkJcAqXUrP+/EGJ2Ei5CXIKrrroKwzDo7++nvb291s0Rou4prbWudSOEaAS2bRONRmXkIsQlqOtw0VqTdnwcHzyt8TQYCkwFplK0RwxMQy50UR1aazKupuDpWftfKmIQkf4nqkRrTc7V2L7G8zWuBgWYBlhKkbAUMbN+i09WrRtQorVmouAzkvcYsT3O5FyGci55T6MBNJRSUAFKBT/g3rjJwqRFb9ykL2bSHTMlcETFSjcyI3mP4XL/88i5Pj7M2v9MBT0xi/6kSV8s6IM9cVMCR1RMa03W1cXXP5fhnMepnEvGmb3/Uex/XVGThYni61+x/9VL4NR85DJuexwYt9k/XiDr+rj+2eZYSmEqRelaVZz9AWuC0YzrQzF+MJUiaipWdkRY0xVjUdKSEoa4oLTjc3DcZu+YzZTj483oT5ZSKFUMFC7e/ywDlrdFWNsdZ2mbhSH9T1xA3vU5NFHgvTGbcdvD1UHQQNCfTAWGUrP2P7/Y//ziW41i/1uStFjbHefK9khNb7RrEi6+1hxLO+wbs/lwysHxNYZSRAyFVfxhVkrrYNjo+hpXa0ylWJAwub4nztUdUaKmXOQioLXmRNZl35jNkckCtqdRKKJGcHHOtf95Glyty/25O2awrifO6s4oCas+7iZF7WmtOZP32D9mc2CiQN71UUoRUWAZCoPKVyTO7H9KKToiBmt7YlzbFaU9YlbnH3MB8xouWmv2jtnsGc4zVvDRWhM1gos6zBFGKWjyng9A0jJY1xPjlr543QwZxfzTWvP+pMMbZ3KcyXv4WhMxFLGQ+x8ENzl5X6O1Jm4arO6KsmFBglRE+l8rO552+NFQjpM5F8/XWEoRM1XoI1zP1+Q9jY8OqjntUW7rT9AVm7+QmbdwGbc9XjyZ4diUC0DcVFjzMGTzdfBD9rSmJ25y7+IUy9oiVf++or5kHJ8dp7IcmijgF1/wLVX9Z1Z8rbE9jaM1HRGDjYuTXNMhK85aje35vH46x3tjNq6viRkGEaP6/U/rYEFAwdckLYM7+hNc3xObl/5X9XDRWvPuqM3rQzmyrk/CrM0KG09rsq6PZSiu745x+8KEjGJagNaaw5MFdpzMMun4xA2jJiVSv9j/lFKs6oyycVFSRjEt4nja4cUTGUZtr2oj5YvRWpP1NFrD8naLexenqj6KqWq4TBQ8XjiR4diUg1KKpDn/P9TpSinu+MEo5r7FKZbKKKZpTR+taB3cudV6gr3gafK+L6OYFjBztJK0DMwa/64dX5Pz/HkZxVQtXE5lXZ46NsWkU7vRyvmURjERQ3HvkhRru2O1bpII2bjtsfXYFCN5r2ajlfMpjWIMpbitP8GGBXEJmCaTdXy2H09zIuPUbLRyPuVRDHB9d4x7lySrctNVlXD5KO3w9PE0WdenzTLq5oc6XekHrBTcvTDJTb3zU4cU1Tecc9l2LM14waOtDkYr55NzfTzg5t4YGxclpf81iamCx9ZjaYZyLimzfh/0tj2fgq+5tivGp69IhT4HHnq4fJxx2HYsTb6Og6VEa02umOB3L0pwS1+i1k0Sl2kk7/LkB8GIuZ6DpSTvBc923dQbZ9NiCZhGl3Z8vvfBJMN5j1QdlMEupuBrbM9nVWeUh5a2hRqEoc4ons66PNUgwQLBSo2kZaCAV0/neG80X+smicswUfDYdizdMMECEC+WjN8atdk5lGMenwwQIcu5Pts+nGI4H4yY6z1YAKKGIm4aHJoo8MLJDH6I/S+0cJkqeGw/NlXXpbDzSVoGWsNLJ7N8MFWodXPEHNiez7YP04zb9V0Km02suCz6R2fy7B2za90cMQee1jx9PM2pnEuqwfpfMCdk8F7xBicsoYSL1pqXiks9Uw0WLCVJU+H4mpdOZMm5fq2bIyq083SO4bxbFyvC5iJuGqCDEfS47dW6OaJCb4/kOZ52SJqNMWKZKWoGWx3tGc5zMuuE8jVDCZf94wWOTDnEzca8sCEokaUsg7GCx2uns7VujqjA8bTDu2M2EUM15IVdkrQUWdfnxZMZKY81kJG8y66hXHFvucbtf/HiDfYLJ7I4/uX3v8sOl6mCx6vFF+NoA/9gIdhTKmYo9o0V+GBSymONwPZ8XjyRKT713Nj9TylFwjQ4NuXy7qiUxxqBp4MXY9vTJOpouftclOagz+RcfhRCeeyywqVUDks7PqkG/8GWRA2FV/x3SXms/u08nWPU9oKFGQ08aimJGMEuzK8PSXmsEbw9kufjjEPCbI7+V9oJ/K2Ryy+PXVa4HJo4Ww5rhh8snFseC3NyS4TvRKY5ymEzJc2gPPbySSnP1rNx22uKcthM08tjl7N6bM7horXm7ZF8eWfjZmIoRUQpDozbZBwZvdSrd0dtnCYoh82klCJuGBzPOAzn3Fo3R5zHvjG7KcphM5XKs8N5j2NTcx+9zDlcTuc8hnJesMqlCcVMhe1pDk3I3Es9mix4HJ0qhH5cQ72IGME+UPvGZe6lHhW84Hdjqubsf5ahykekzNWck2HvWB5Pa6zm+7kCpdPfFO+N5kN9sEiE48B4gYLXfKOWElUePRfK5xKJ+vH+ZIGM4xNrslHLdFFDcSztzHnub07hknV8Dk8UikfANu8PN24qxgo+x9LhrPsW4XD94I7KaPL+FzMVOTe41kT90FrzXvGOvpnm+maKGsHcy/45jp7nFC4HJ4KjYZs5tSGcoaEI3wdTDlMFn3iTjlpKSmenvzdqy3MvdeR0zmMo6zbtlECJUsFCmX1j9pyee5ljuNgowj+asx5FDcXxKYesTOzXjcMTNhpdt7vNhilmGozkPc7kZVlyvTgyWWjqKYHpYqYi42iOz6F6U3G42J7PmO3RKofoWYbC0TAszxzUBa01p3NeU5cjprNU8KDesIRL3TiVdVE0d0m2xFQKzdz6X8URMZr3cP3mrjVOZxC8oI3kZUloPUg7fnBcdYv0v9ILmPS/+uD5mpG8h9UiN9clZ+awJN6q9BOG8x6+1qGGy+99bYADu3awYNmV/MEzb57zvqFjR/nVR9YD8MQv/TrtPb28+r1v8eG+dyjkgofM/u3W11m8cnVo7ZmudHEP5+TOsR6M5D08H2IV99wLq6QPfvc//u55v86v/tcnue72TaG2TaE4nZX+Vw/GbA/H16GfrFtJ/zvz0Qcc/NGrTAyfRmtNZ18/N933MJ/9Z79GW1d3qO2CYCAxlHPRWlc0Wqs4f0eKw6Mwh4SbnvhxAM4c/4BDb7x2zvteefLbwfczDDZ+9ku889L3+XDfO7R394b2/S/GVIpTxR+uqK1h20OjQ5/vu9Q+2LP4ClbeuOGcP10LFpU/trOvP9R2AVgGjNpuKJsJisszbHtVmW+p5DXwzR9sQ/sei69aRXtXD2eOf8D3/+o/8X//8s+G26giy1DkPc1khfPOFYfL6ZxLcLxWeDY8/BliyRQAr3zvW+e879XvBT/YNbffQ++SZXz1N/6QP911jM/9wq+F2oYLMRVkHJ+sKxd3rc1leH4pLrUPbvrcV/jfvvXsOX/aunsAWHf3/VUZQVtK4fpBSVrUVjVurqGy18A/fmEvf/DsHn7zb5/jD3/4DqtuvROAw2+8HmqbSiwVLP8fqbD/VRQuntZMFDzCXoEXT7Wx4eHPALDrqb/HKQRLfw+/uZOhY0cA2PjEVwDo7l+MYZrhNuAiLEPh6eCkQ1FbI/nqTOZX0gene+el7/PRwb0APPbTvxh6uyC4uXG1Zlz6X82NVmnuq5L+F4nF+bv/8Lv89pce5F89cCOHdgcjnVW33lGVtpUeKK/0YcqKYsL1NVoT8rglUBoWZibGeev5pwF4tTgcTLS1c+tDj1fhu14aBWgNskly7Tm+rkr/g7n1we3/5f8EYNl117Nu4/1VaZcqPu8iD+rXXsEP5sCqoZL+d/rD9zny9m5GThwHYO1dn+Ln//gvqtIuABRUWripKFx8DZrq/HCvvW0jC5auAIJhoes47Nz+XQA2PPI5Yolk6N/zUilAo/FkzqXmqjntUGkf/HDv2+x77UUAHv2pX6hew4qk/9We62uqtVCxkv738//+v/Cf3x7if/+7F7li1Rr2vvo8f/Vbv1ydhgFojVfhxVdhWSwIl2oEt1KKuz/7ZQDefvFZXvmHb5IeHwVg0yzliFrw5NquOU9TtYu70j741F8Eo5aexVdwx+bPV6dRpbYh/a8e+FWq3EDl/c+KRFi+5gbu++JPAkEgnTp6uCpt01Te/yoKF1MVf7BV6uQbP/cVlFJ4jsPffOPrAPQvX8nqW++qzjesUJPvdtMQTBWUKKvlUvvgyInj7Hrq7wF46Kv/BNMKeW30DBrpf/XAUFV7+QMu3v+OvPMG+3e+XP54t1Bg76vPl/9u56pzBpCi8v5X0RVhqLMlomrk94KlK1i94W4O7NpBPpsGgh/2dN/+w99k97NPks+ky2/7o5/5PGYkwoM/8XM89NWfC71dpVJgqzw4Ws+qvePLpfRBgGf+8s/wXJdEewf3/dhPVrdRRdL/ai/Yb7B6X/9i/e/E4f38+df/GanOLnoWL2X05MdkJsYAWL7mBpZdd311GqZUxdstVTRysYpHsFYzuUuTWnB2Xfd0kyNnGDp2lMmRM+W3jZz8iKFjR8s/5LBpglJMqz2VW48ihqpq/4OL98Hs1AQv/u1/A+BTX/xJEqn2qrZH6+B2rsn3SWwIUaN0c109F+p/V6xaww33PEAkGufE+wco5HMsufpaHv3pX+BX/uJ7GEaVOomm4md7lK7wycBvHZ5gOOeRapXNxQj2U9PAV1d3tdS/ux5tPzbF4YkC7ZH5XY5eS66vKfiaz6/sYGGyuuU3cWE7TmV540yupfqfrzUZ12fLinZWdkQv+fMqfqVcmLDwq37vWF88DamIQbIVtkGtcwsSrffi6mqNZUBPvHVe0OpVb/F30Eq7dbg6qFr1Vtj/Kg6XVvzhelqzKGG1xC6o9a4vZqJQLXU6qOtDT8wKfT8rUbm+mImpVMXPfDQy19fETUVHhVWbisOlL25iKNUyyyJLIdqXkLvGetAbNzGN1nqgVaNZmJT+Vw+6YyYRQ7XUM0ee1vTP4ea64nDpiZtYRus80OUTrD/vjbdeOaYetUUMkpaB2yL9r3RzI/2vPpjF8lAr3dzA3MrRFYdLzDTojpm0ysGMrq+JqGA4LGpPKcXChNkyNzeuDpYg98l8S91YlLTQ6JaYGvC0RjG3/jenpU+rO2NodEvUvQu+Zll7hKSsEqsb13TGUKiKt6NoRLbn0xs3WSDhUjdWdkRbZt7F9jSpiGJZW6Tiz51juESJmQq7ySdegn2EFGu7Y7VuipjmyvYI7VGDfJOHi198vmVdT0wWk9SRhQmT/qRFvsl3EtU62E9xTXdsTotJ5hQuyYjBNZ1RXN3cQ8O8p+mOGiyfQ2qL6rGMIPD9Ju9/tqdJWMG1JuqHUop1xRvOZi7PFoonbl7XNbeb6znXetZ2x5t6aBjcNWrW9cRDP/VQXL5ru6JETYXdpKMXrTWO1lzbFSUuj+bXnas7oqQiRlNXbwq+ZnlbhK45zjfPudcuTJj0J8ymHRraniZmKlbJXWNd6oiaXNUepeA35+jF8YOtbtbM8a5RVFfUDH43XpOOnsOYEphzuCiluLE3jlKKQpPdPfrlu8aYbPdSx67vCWrBzTZ60VqT932WpSL0teCOBI1iTXeMmKnINdnoRWtNzvPpi5ssb5/7lMBlvXKu6oyysj1C3vObJr11cR+d7qjJ7f2JWjdHXMCSVITru2M4fnMd5Jb1NEnLYNPi2h2QJy6uK2ZyW38CT2vcJrrByXvBXMt9S5KXNSVwWeGilOKexUnaIgaZJknvgq8xi/+uhGyDXPduX5igJ2aSdZvjBscpHiV+R39izrVuMX9u7I2zNBUh1yQ32J7WuFpzU2+cxcnLW8h02a+e7VGTuxYGd1iNXh7ztcb2NWu6o1xZwe6fonZipsG9S1JYTVAeK5UjVrRHuL5H5loagakU9y1JNUV5TGtN1vVZkLDYEELVJpRb8+u6zpbHGvXByunlsDsXSjmikSxra47yWNYNymH3LE7Kcy0NpCfeHOWx6eWwMDZJDSVcSuWxjohBpkHLE9niD/aeJVIOa0S3L0zQF7fIuo15g5P3fFBw10IphzWiG3vjLGuLkPX8hrzBKXhBOezmvssvh5WE9iraHjV5bHk7Scsg3WABk3V9lIJ7Fie5sl3KYY0oZhpsXtFGh6VIN1jA2J6Pq2HDgrjsBtGgTKV4ZFkb/TGDjNNY/c/xNbbvs64nFuoipopPoryYjzMO246lybs+bZZR18P7oMYdbLFx96IEt/TJ6rBGlE6nOXLkCHv27OHj8TTqpk+T7O6jLWLW/QOwec/H9TU39cXZtEjKYY0ol8vxwQcf8Pbbb3Pk45Oomz5NvG8x7VELs85/nwVfY3s+qzqjPLS0DTPEM4NCDxeAj9IOTx9Pk63jgNFak/U0SsHdC5Pc1Bsjk8kwOjrK0qVLq3cWtQjF1NQUR44c4ejRowwNDZHP55mcnATA6Oih//4vkMWkzTLqNmByro8H3NwbY6MES0PJZrMcPXqUo0ePcvLkSWzbZmJiAq01RqKNBZ/+AjkrQdI0sOr0kDfb8yn4muu6Ytx/RSr0dlblCa2lbREGVrSz/dgUk45PwjTq6hQ9r7gqImIo7l2SYm13DM/z+O53v0sul2Pp0qU88sgjmKbUvuvJ5ORkOVDOnDkTbJHiOGQyGWzbBsAwDDoMn8+v6mH78TTDeY+4YRA166f/+cX+ZyjFHf0JNiyIS7A0gEwmUw6UU6dOobWmUCiQzWbJ5/NAMP8cVz5fWN3LD087nMg4RLQiZqi6+R2Xbqw1cENvnHsXX97zLOdTtcd/FyYtnljZwQsnMhybcin4mqRZ2x+wLi41dnxNT9zkvsUplhY3pVTqbNs++ugjnn76aR5++GEsS56QrqV0Os2hQ4c4evQow8PD5Qvatm0KhQK+7+P7Z7cgSiQSrF+/nu64xeeu7ODlU1kOTRQoOD7JOhjFFLzg6fuOiMGmxSmu7ojUzYuO+KRcLsfhw4c5cuQIQ0NDn+h/nufh+z5KKbTWxGIx1q1bR3cqwcCKGDtP53h3zCbtBv2v1mUyxw+WuyctgzsXJljXXb0dt6tSFptOa827ozavD+XIurUbxZRGK5ahuL44cRWbsSHgqVOn2L59O47jAHDFFVfwyCOPSMDUSDqd5jvf+Q6FQuGcCxrANE0Mw6BQKKCUwvM8TNOkr6+Pz372syxcuBAI+t/hyQI7TmaZdPyajWJKoxWlgv3qNi5KytZCdc51Xb75zW+SzWbP6X9aa0zTxDTN8oi5FDD9/f18+tOf5pprril/neNphxdPZBi1PSJGbUYx5dGKhhXtEe5ZnKz6qsSq926lFDf0xvnCyg6ubI9ie5q048/bevDSRZ11fXriJgMr2rlnceoTwQKwaNEiNm/eTCQSjGY+/vhjnn76aVzXnZe2inPl83kcxyGbzTI1NYXjOCSTSbq7u0kkEjiOU75jBEilUqRSKfr7+8tfI3gxj/HFqzu5riuGozVTjld8Er76fdDXmpzrk3Z92iIGjyxr46GlKQmWBuA4Dvl8vjyfZ9s28Xicrq4ukslk+cYGgn6WSqUwTZMVK1ac83WWtUX4wtUd3NwbRwNp16fgzU//01qT93ymXJ+YqfjUFUkGVrTNy3L3eevhXTGTx1e0cf8VSbpjBrYfXOR2FbZN0DoofU05HhnXJ24qbutP8IWVHRc9UW3hwoWfCJinnnpKAqYG+vr6uPHGG0mlUsTj8WCy1DBwHId0Ol3+uEgkgmmaxGIxVq5cOetdYSpi8NDSFI8sa2NhwsLxNWnXr9q+eG7x62eKo+WbeuN88epOrumMShmsQSQSCe666y7i8TipVAoIQsT3faampsofF4lEMAyDWCzG8uXLy68d08VMg3uWpBhY0c7SVASXoH/kqrRs3vM1GSe4qVEK1nTF+MLKDq7vmb/5vaqXxWbja82xtMO+MZsPpxwcX2MoRcRQWIo51cW11rg6uKhdHewP1p8wWdcT5+qOaMWlkNOnT7N9+/ZyGWbJkiU88sgjs3YcUT1aa1577TXeeecd0uk02WwWoLyaL5FIlIO/s7OTz33uc+eMXM73NU9mXfaO2RyZLGB7wTnhUUNhGXPvf54Gt3hjYyhFd8xgXU+c1Z1ReTC3gb377ru88sorZLPZ8k1Nqf/FYsGcRaFQoKenhwceeICrr776gl9Pa82ZvMf+MZuDEwVyro8iOGLBMhQGVBwAM/ufUoqOiMG6nhiru6K0R+Z/cVJNwmW6cdvjwLjN/vECWffccpmpFJZSKAWK4E/pvZogSDwNuvhWUymipmJlR4Q13TEWJazLSumhoSG2bdtWDpjFixfz6KOPSsDMs1LA7Ny5k8nJyfIIJpVKkUgkGB0dpa2tjQULFvDlL3+5ot95xvE5MG6zd8xmyvHx/HP704X6X7Ddx4yPN2B5W4S1PXGWpS6v/4n68c477/DCCy8wPj6O7/sYhkEikaCtrY3R0VHi8TidnZ189atfrej1Ie/6HJoo8N6Yzbjt4WrKI2lTKczizfb5+p/ng198q1Hsf0uSEdZ2x7iyPRLqcyuVqvlMdVfM5I6FSW7vTzDp+AznPEZsjzM5l6GcS744CYU++4NVgFIQMRWLYiYLkxa9cZPemEl3zAztB9rf38/mzZvLAXPy5EmeeuopCZh5Vqpne56HYRj4vl+eVC0FfzQaPW9J7EJSEYP1CxLc0hcn7fqM5D1G8h5DOZehnFcsWzBr/zMVLEpaLEya9MYt+uJB/6unZfciHG1tbeVQAcr9z3Gc8iqx85XELiRuGdzQG+f6nhhZVzNie4zkXYZzHqdyLhnHx9F61v5nKOhLmCxMWPQlzOJroFU3y+5rPnK5EK2DyX/HL6a0Dn6gllKYBrRZxrwk85kzZ9i6dWv5hWzRokU89thjEjDz5J133uHVV18NNhfNZMp1b9u2MQwD0zTp7OzkiSeeYMGCBaF932Az06DM4PlB2dUohoqpFKlIfT2/JarjyJEj/OAHPwh29MjlcF0X0zTJZrPlsOnp6eHBBx9k5cqVoX3f0g4itjd7/0tYataFSfWirsOlnpw5c4Zt27aVlx5KwMyPUrCU3HLLLdi2zd69e5mamsK27TmXxIS4mOnBArB69Wq6u7t5/fXXyWazZLNZEokEXV1dfPWrX5XHFqaRn8QlWrBgAVu2bGHr1q3Yts2pU6fYtm3bOSvLRLjefvttXnvttfLfb731Vm699dbyhb53716UUnMuiQlxIe+//z4//OEPy/3t2muv5d577y33s9dffx0ISrLLly+XYJmhfsdUdaivr48tW7YQiwU7154+ffqcCX8RnrfeemvWYIFgDmbjxo2sXbuWtrY2IpEIq1evrlVTRRO6WLDcdNNN3H777SSTSSzL4rrrrqtlc+uSlMXmYHh4uDyCgeDZmMcee4xoVLbrD8Nbb71VvisE2LBhA+vXr//Ex2mtOXHiBPF4nN7e3vlsomhihw8f5rnnnisHy3XXXcc999wz68j49OnTAOUdIcRZEi5zNDIywtatW8sb1knAhGPPnj3s3Lmz/PfbbruNW265pYYtEq3k0KFDPP/88+VgWbNmDZs2bZKS6xxIuFyGmQFTWrosATM3b775Jrt27Sr/XYJFzCcJlnBJuFym2QLmscceK8/LiEszM1huv/12br755to1SLSUgwcP8sILL5SDZe3atWzcuFGC5TJIuIRgdHSUrVu3ksvlgGBl2ebNmyVgLtEbb7zBj370o/Lf77jjDm666aYatki0EgmW6pBwCYkEzNzs3r2b3bt3l/8uwSLm04EDB3jxxRfLwbJu3TruvvtuCZYQSLiEaGxsjMHBwXLAzFy6LM41M1juvPNObrzxxhq2SLSSmcFy/fXXc9ddd0mwhETCJWQSMBentWb37t288cYb5bfddddd3HDDDTVslWgl+/fv58UXXyz/XYIlfBIuVTAzYHp7e9myZQvxeLzGLas9rTU/+tGPePPNN8tvk2AR82nfvn289NJL5b/fcMMN3HnnnRIsIZNwqZLx8XEGBwfL549IwMweLHfffTfXX399DVslWokEy/yRcKkiCZiztNbs2rWLPXv2lN8mwSLm0969e3n55ZfLf7/xxhu54447JFiqRMKlyiYmJhgcHCSTyQDB1txbtmwhkUjUuGXzR2vNzp07eeutt8pv27hxI+vWrathq0Qree+999ixY0f576W9wSRYqkc2rqyyzs5OBgYGymdwz1yy3OwkWEStSbDUhoxc5snMEUx3dzcDAwNNPYLRWvP666/z9ttvl9+2adMm1q5dW8NWiVby7rvv8sorr5T/fvPNN3PbbbdJsMwDCZd5NDk5yZNPPtkSAVM69/6dd94pv+2ee+5hzZo1NWyVaCUzg+WWW25hw4YNEizzRMJlnk1OTjI4OEg6nQaCgNmyZQvJZLLGLQuPBIuotdlOMJVgmV8SLjUwM2C6uroYGBhoioDRWvPqq6/y7rvvlt927733ymFKYt7MDJb169dz6623SrDMMwmXGpmammJwcJCpqSmgOQJmZrAopbj33nu59tpra9wy0SrOdzS2mH8SLjU0M2BmrixrJFprXnnlFd577z1AgkXMv5knmEqw1JaES401Q8BordmxYwd79+4FgmC577775Fx7MW8u9WhsMX/kOZcaa29vZ2BggPb2duCTS5brnQSLqLU9e/ZIsNQhGbnUiXQ6zeDgIJOTk0BjjGC01rz88svs27cPCILlU5/6FKtWrapxy0SrkKOx65eESx2ZGTAdHR0MDAzQ1tZW45Z9kgSLqDU5Gru+SbjUmUwmw5NPPlnXAaO15qWXXmL//v1AECz3338/11xzTY1bJlrFzKOxJVjqj4RLHcpkMgwODjIxMQF8cl6mlrTWvPjiixw4cAAIguXTn/40V199dY1bJlqFHI3dGGRCvw6lUikGBgbo7OwEPrmirFYkWEStzXY0tgRLfZKRSx2rpxGM1poXXniBgwcPAhIsYn7NdjT2nXfeyY033ljDVokLkXCpc9lslsHBQcbHx4HaBMxswfLAAw+wcuXKeWuDaF2zBYscjV3/JFwawMyAaWtrY2BggI6Ojqp/b601zz//PIcOHQLAMAweeOABrrrqqqp/byFmOxpbgqUxSLg0iGw2y9atWxkbGwPmJ2AkWEQtzRYscjR245BwaSC5XI7BwcFywKRSKR5//PGqBIzv+zz//PMcPnwYCILlwQcf5Morrwz9ewkxk9aaXbt2sWfPnvLb5ATTxiLh0mBmC5jpK8vC4Ps+zz33HO+//z4gwSLmlxyN3RwkXBpQLpdj69atjI6OAuEGzGzB8tBDD7FixYrL/tpCXMxswSJHYzcmCZcGVY2A8X2fH/7whxw5cgQA0zR58MEHJVjEvNBa8/rrr/P222+X3yYnmDYuCZcGls/n2bp1KyMjIwAkk0kGBgbo6uqq+GvNFiwPPfQQy5cvD7PJQsxKjsZuPhIuDS6MgPF9nx/84AccPXoUkGAR82u2YJGjsRufhEsTmC1gtmzZQnd390U/d7Zgefjhh1m2bFlV2ywEyNHYzUzCpUnYts3WrVsZHh4GIJFIMDAwcMGA8TyPH/zgB3zwwQeABIuYX3I0dnOTjSubRCwWY8uWLfT19QGfXLI802zB8sgjj0iwiHkhwdL8ZOTSZGzbZtu2bZw5cwYIRjBbtmyhp6en/DGe5/H973+fDz/8EDgbLEuXLq1Jm0VrkaOxW4OESxO6UMDMFiyPPvooV1xxRS2bLFqEnGDaOiRcmtTMgInH4zz66KO88cYbHDt2DADLsnjkkUckWMS8kGBpLRIuTaxQKLBt2zaGhobQWpPNZonFYliWJcEi5pUcjd16ZEK/iUWjUTZv3syCBQuYnJwkl8uVDx6TUpiYLxIsrcmqdQNEdZmmSSQSoTRALf1vNBqtZbNEi5CjsVuXjFyamOu6PP3005w4cYLOzk6i0Wh577Hpz8QIUQ2lE0wlWFqThEuTKgXLRx99BAQjlS996Uvl5calhy5LE/5ChOl8R2NLsLQOmdBvQqVg+fjjjwGIRCI89thjLFq0CMdx2L59O6dOnQKChy9L8zJChEFOMBUgI5emc6Fgme3vM5csC3E5JFhEiYxcmojrujz11FOcOHECCIJk8+bNLFy48BMf6zgOTz31FCdPngTOrizr7++f1zaL5qG15rnnnjvnaGwJltYl4dIkHMcpT95DEBaPPfbYrMEy/XMkYEQYfN/n+eefPydY5Gjs1ibh0gQuJyTmEkpCTCdHY4vZSLg0uDBGH5WU04SYToJFnI+ESwObufIrGo2yZcuWOa38mm0hgASMuJDZjsZ+8MEHJVgEIOHSsKqxpPhiK82EKJGjscXFSLg0IMdx2LZtG6dPnwbCfVbFdV2eeeaZ8sOXkUiERx99lMWLF1/21xbNQY7GFpdCwqXBFAoFtm/ffk6wTD+BMgwSMOJ85GhscakkXBrIfARLied5PPPMMxw/fhwIzn557LHHJGBamASLqISES4OYfjYLBMEyMDBAb29v1b7nbAHz6KOPsmTJkqp9T1Gf5GhsUSkJlwZg2zbbt28vB0s8HmfLli1VDZYSz/N49tln5fTKFiZHY4u5kHCpc7MdVzxfwVIiAdO65Hcv5krCpY7NFiwDAwP09PTMe1vk7rX1SLCIyyHhUqdmBksikWDLli01CZYSqbu3DplvE5dLwqUOlQ7yKp0UmUgkGBgYoLu7u8Ytm33FkARMc5GVgiIMEi51pp6DpcT3fb7//e/LktQm5HneOSeYyjNOYq4kXOpIPp9n69atjIyMAPUZLCXylHbzkYdnRZgkXOrEzGBJJpMMDAzQ1dVV24ZdgOwv1TxkXzkRNjnmuA40YrDA2ZMGV65cCXxydZFoDBIsohpk5FJjuVyOrVu3Mjo6CkAqlWJgYIDOzs4at+zSyZkejUvO8hHVIiOXGmqGYIEgTO6//36uvvpqIAibZ599trxkWdSn0kFzEiyiGmTkUiO5XI7BwUHGxsaAxg2W6eQc9cYx2wmmcry1CJOESw00Y7CUzBYwDzzwAFdddVWNWyZKwjgaW4iLkXCZZ9lslq1bt5aDpa2tjYGBATo6OmrcsvBorXn++ec5dOgQIAFTT8I8GluIC5FwmUfZbJbBwUHGx8eB5gyWEgmY+lONo7GFOB8Jl3kyM1ja29sZGBigvb29tg2rIq01L7zwAgcPHgRAKXXO0mUxf6p5NLYQs5FwmQeZTIbBwUEmJiaA1giWEq01L774IgcOHACCgPn0pz9dXlkmqm8+TzAVokSWIldZKwcLBGFy7733cu211wJB2Pzwhz8sPxMjqkuCRdSKjFyqqNWDZTqtNS+99BL79+8HgtC5//77ueaaa2rcsuY1W7BU+2hsIUqsWjegWaXTaQYHB5mcnASgo6ODgYEB2traatyy2lBKcc899wCwf/9+tNY899xzABIwVVDLo7GFABm5VIUEy/lprXn55ZfZt28fEITOpz71KVatWlXjljWPejgaWwgZuYRstmB5/PHHSaVSNW5ZfVBKsWnTJgD27dtXXrIMSMCEoJ6OxhatTUYuIZqammJwcJCpqSkAOjs7GRgYkGCZhdaaHTt2sHfvXiAInfvuu4/Vq1fXuGWNqx6PxhatS8IlJBIsldNa88orr/Dee+8Bn1xZJi5dI5xgKlqLLEUOgQTL3CiluPvuu1m3bh3wyWdixKWRYBH1SEYul2lqaoonn3ySdDoNQFdXFwMDAySTyRq3rHForXn11Vd59913gbMry6677roat6z+NdLR2KK1SLhchsnJSQYHByVYQqC15rXXXuOdd94pv+3ee++VgLmARj3BVLQGCZc5mhks3d3dbNmyRYLlMswWMPfccw9r1qypYavqkwSLqHcy5zIHExMT55TCuru7ZcQSAqUUd955JzfeeGP5bS+99FL5mZjZjI6Oln8PraJ0HpAEi6hnMnKp0MTEBIODg2QyGeBssCQSiRq3rHlordm5cydvvfVW+W2bNm1i7dq153zc7t272b17N5FIhC984Qstsa1OsxyNLZqfjFwqMDNYenp6JFiqQCnF7bffzk033VR+28svv1xesgxngyWTyVAoFMrb+jez0ohFgkU0AnlC/xKNj48zODhINpsFgmDZsmWLBEuVlAJGKcWePXsA2LFjBxAsvS0FSy6Xw7Isjhw5wvr161FK1bDV1dPMR2OL5lT34eL4GtfXuFrj62CoZSqFaUDUUPPyYjIzWHp7e9m8ebMES5UppbjttttQSvHmm28C8Oyzz6KUwvd9crkcSiny+TxjY2OMjY2F/jS662scX+Np8LRGcbb/xeap/7XC0dii+dRVuNiez0jeYyTvMZx3OZX1mHQ8tIbpE0Oq+CdhGSxKWvTFTXrjJr1xi5QV7gU/W7Bs2bKFeDwe2vcQ56eUYsOGDUAwcslkMvi+j1KqPMeSyWTQWvP+++9fVrg4vi72P5eRvMfpnMuY7eGfp//FTMXCpMWCuFXsfybtESPU/tdKR2OL5lLzcMm5PgcnChwYtxnLe7ga/OIaA4PgDtFAUfwPoBg2mrTjc2Dc5gDBi5ClIBUxWNUZ5dquGN0x87LaNjY2xuDgILlcDpBgqRWlFJZlobXG93201uUX8FgsRiaTwbZtjhw5woYNGyp6cS94mvcnC+wbsxnOuzj+2f6nUFgX6H9ZV3N4osDhiQIAlqFImIqVHVGu646xIG5eVtDMFiyPP/54SyxcEI2vJqvFtNYM5Tz2j9scHC+Q94I70YgCSykMRcUXpa81rg+O1vhaYxmK5W0R1nbHWN4ewazw680Mlr6+PjZv3izBUgN79uxh586dZLPZ8rJjwwjWoqRSKQqF4MW9s7OTz3/+85e0tfxoPuh/+8Zssq4PQMRQWEphXkb/c3VQwo0YikUJi3U9Ma7qiBIxKvt6ctCcaHTzGi5aa45OOewZznMq5+L5GkspYqbCCLGUoLWm4Ad/lFJ0RQ2u74lzQ08M8xIu8tmCZcuWLcRisdDaKC7NW2+9xeuvv042myWbzZafJSqVKQEikQiO49Db28stt9zC7bffft6v91Ha4c3hPB9lHFxfYypFvAr9z/HB9oPQao8YrO2Jc1NvjJh58QWaEiyiGcxbuGQdnx2nshycKOBrTcw0iMzhDrFSrq/JexqNZnHS4r4lKRYkzl8NHB0dZevWreVgWbBgAZs3b5ZgqYGxsTG+853vlINFKUUqlSIajZLP58sBo7VGa01HRwf9/f186Utf+kS/sj2fnUM53h21cXxNzFDzsiDE00H/87WmN25y7+IUS9si5/14CRbRLKo+56K15v1Jhx2nskwWPGKGQdSav8drLEPRZihcX3Mi6/J3Rye5tS/BLX3xT4xiRkdHGRwcJJ/PAxIstWYYBqZpEo/HUUph23a5LBaJRIhEIhQKhfLqsUwmw+TkJCMjI/T19ZW/zkdphxdPZhjJe0QMRbsV7qT7hZhKkbIUng4WCzz54RQ39MS4rT/xiVFMJpPhySefLB80197ezuOPPy4nmIqGVNWRy/TRitaapGWEWn6olNaanKfxtGZR0uJT00YxWmu+9a1vlS9sCZb6MDo6yv79+zl69Gh5pVihUMC2bRzHKU/wQ/A7bG9v5+677+aOO+44Z7Ti+kH/q3TuLUxaa+zi0ubZRjFPPvkkJ0+eBORobNH4qhYuY7bH1g+nGLOLoxWzfh5uc31N1vNJmIoHlraxsiOK67r81V/9FYVCgf7+fjZv3kw0Gq11U0WR1pqhoSGOHDnC0aNHSafT5aDJZDI4jgMEo52+vj5+4qd/lu3H05zKukQMNW/PpFwKT2uyrk/EUGxclOSG3jhaa7797W8zMTEhR2OLplCVcBnKuWw/lmai4NFW49HK+Witybg+lqH41BUpruuKMTIywvDwMCtXriQSOX9dXNSW1pozZ85w9OhRjhw5wtTUFJlMprwtj5FsZ8kjX2HSN0mZxiUt4phvpVE0wJ0LgzLt5OQkJ06cYOXKlTJiFg0v9HA5k3MZ/HCKKcev22Ap0Tp4VsEw4FNLUqzplgu60WitGR4e5siRI+zZs4eRTB7j5gdI9C2iLWLWtAx2KXKujw/c0Z/g1gXxuhldCXG5Qg2XMdvjex9MMVHw5nXS9HKUAsY04KGlbVzdKaWwRpUuePzd4VHGXUVbxKzrG5vpSgFzz+IkN/bKc1SiOYS2bCvn+mz9cKpcCmuEYIFgKXTSUrgafvBxmhMZp9ZNEnPg+JqnP8ow7hmkGihYINjGSAE7TmXLT/sL0ehCCRetNS+fyjJq1+8cy4UopUiZCtvTPH8iQ8GTI24azRtncpzIOCTN2q4Im6uEqfA0vHQyQ9rxa90cIS5bKOFyZNLh0HiBmBHuk87zKRjBGIzkPXYNZS/+CaJunMq6vDmcx1IKqw4n7y+FUoqkqZhyfF4+mWGenm0WomouO1yyrs/Lp7J4xafuG5mpFBFD8faozcdSHmsIjq954USGgq+J19Fy97kwlCJuGLw/6XBQymOiwV1WGmit2XEqy0TBIzWPT91XU6z4NP8LUh5rCG+cyTGUc0mZjTPPdyFRU6GBV05lpTwmGtplJcIHU41fDptpenls95lcrZsjLmAod7YcVo/PssxVqTy245SUZ0XjmnO4aK15ayTfFOWwmUwVbL3+3phN3pW7x3r17mgepwnKYTMZKthR4MhkgTHbq3VzhJiTOafCcN7jZNYlZjRXsJTETEXO9Tkkte+6lHF8Dk8UiNTRti5hihbLs/vH7Fo3RYg5mXMy7BsLti6PNGe2YCiFAt4bs2XlTh06OGFje5poE5XDplNKYSrF/nFb5v5EQ5pTNOSLRxNHVHPeNZbEzGDu5eOMW+umiGl8rXlv1EbRPHN9s4mZirTjc2RSRs+i8cwpXA5NFMi5PrEmq3XPZKnghWyflCbqyrEph/GC33RzLTOVHgZ9V0bPogHNKVwOjBdQ0NR3jRCUJiKG4shUQSb268ihyeA000Z9YLISMdNgKOcyIhP7osFUHC6Orxm13Za4sAEihsLxgwUMova01pzMuFhNfmNTElHg+ZrhnPQ/0VgqDpeRvIfj0zIXt0HwgiZ3jvUh6wYHbbVK/yvNaUr/E41mDuHi4mtNk5e7y0oX93BOJvXrwXDexdXQZI9WXZBCcTor/U80FqvSTyjdQYW5Suz3vjbAgV07WLDsSv7gmTfPed/QsaP86iPrAXjil36dz/z8vwIgl5niN5+4lzPHPwDga7/5R9z/5Z8OrU3TGUpxSsKlLozkPbTWBJvUh+eS++Avfp30+CgHd7/KyInj2LksPYuu4PbHnuCxn/klEqn2UNsFYBnBv9vzdVPtRCCaW8X3f6ezLirkC3vTEz8OwJnjH3DojdfOed8rT34bAGUYbPzsl8pv/6vf/pVysFSbpWCq4JOTSf2aK819hb0E/lL74LW33c2z/+3P+PjwfroXLSGWTHH6w/d58s/+kD/9F9W5uTGVKs51SmlMNI6KwsXXmjHbJ+w9Kjc8/BliyRQAr3zvW+e879XvBRf2mtvvoXfJMgB2bv8ur/zDN7nt0SfCbch5WCo4a2NcLu6aO5Nzq7JK8VL74KIrr+HHfvm3+I+vHOK3vvsS//65d7n6ptsAeOel75OZGA+9bZYCV2vGC9L/ROOoKCZcP5jcDvvSjqfa2PDwZwDY9dTf4xSC50oOv7mToWNHANj4xFcAGDn5Ef/13/wLrlx3M//on/96yC2ZnVKgNcgmtbXn+CEenzrNpfbBzgULeeynf7Fc/orE4lx1wy1AMLIxLDP0tqnibhHS/0Qjqeg69bRGQ+hlMThblshMjPPW808D8GqxHJFoa+fWhx7H933+86/+EzzX5ef+3X/GikRCb8dsFKDRePIgW81V83dwKX1wpsmRM/zomScBuGPzP6rKnEuJ50v/E42jwnABDVQhW7j2to0sWLoCCMoSruOwc/t3AdjwyOeIJZI8+5d/xoFdO/jxf/0NFl11TfiNuAjZ4qn2PB2MJKvhUvrgdEPHjvJv/4fHGB86yar1d/C1f/Pvq9MwgktO+p9oJBWFi6GKuVKFTq6U4u7PfhmAt198llf+4Zukx0cB2FQsiR0/8C4A//0b/5p/cutSfv3xu8qf/9+/8XV+5ysPh9+waWShTu0ZxRJlNVxKHyw5/OZOfvvLD3H6w/e5+f5H+Zf/z99VddSikf4nGktF4WKqsyWiatj4ua+glMJzHP7mG18HoH/5Slbfetc5H2dnM9jZDIXc2cOU3IJNIV+dw71KpcBWebannlX7d3ApfXDX0//AH/zUZ0mPjfDgT/xP/OL/9defGNVUg/Q/0Ugqes7FUkG6VOvOccHSFazecDcHdu0gn00DwcVe8jPf+BN+5ht/Uv778MfH+OUHbwKq+5xLqRTYKlve1DPLUFW7uYGL98GxoZP86b/4KbTWWJEoR95+g9/9yiPl93/1N/6QK9fdFGqbSptWSv8TjaSicDENRUfErOp6+01P/DgHdu0APvlsS614frActDMa/kogUZmemFn1JeEX6oOe45Rf7F2nwJG3f3TO5+YzU6G3x9PBg7zS/0QjUbrCvbx/+HGa90Zt2iOt09Gzrk8qYvC11Z1NfX5NI9g5lOP109mW6n95z0cp+Klru4lKbUw0iIofGeiLB4OdVjpfwtOaRQlTgqUO9MWDUPFbqP+5PnRHTQkW0VAqDpfeuImhFK225H5BouJt2EQV9MZNLEPhtlD/02gWJaX/icYyp3ApbUfRCnytUUrRE2+dMkw964gYxE2F2yJ3N6UKQa/0P9FgKg6XuGnQETNbZisKx9dY6mw5UNSWUoqFCatldksoTeb3Sv8TDWZO2zSt6oii0S0x71LwNUtSFm2RFjpApM6t7IgC1d0Kpl7kPU13zKA/ISMX0Vjm9Ip5bXeUqKmwm7w04fkahWJtd7zWTRHTXN0ZpS1iYDf5fii+1mg067rjVdkJWohqmlO4tEdMVrZHKfjNPXrJ+5r2qMFV7fOzQaa4NBFDsaY7Fmyk2sT9z/Y0MVOxqita66YIUbE513rWdMcwVfOu2tFa42vNuu6YnP5Xh67rihExFIUmHT1rrXG1ZlVnlGTYBygJMQ/m3GuvSFn0xk1srzln9m1fEzUVq+WusS51xUyWtUWaNlxcHZxAuUZKsqJBzTlclFLc0BMDFayoaia+1hR8zdUdUTpky426dX1PMHputhscrTU5z2dx0mKhTOSLBnVZ4+013TGWpiLkPb+pat9ZT9MeMbhzYfV3uhVzt7wtwuquKLavm+qJ/ZyniZuKe5YkZVcI0bAuK1wMpbhvSYq4ZZBtkpU7BS84xnnjoqQsP65zSik2LkrSGTXJuM0xenH94MTTDQsS8myVaGiX/erZHTO5vT+B1rrhy2O+1uR9n6s7IqzqlLmWRpCwDO5ZnGyK8pjWmqznsyQV4aZemWsRjS2UW/MbemIsbYuQa/DyWKkctmlxSsoRDeSq9uYoj5XKYfctScoKRdHwQgmXUnksZRmk3cYMmJzrYyDlsEZUKo91x4LyWCP2P9vz8TXc1i/lMNEcQnsV7Y6ZPLysjZipGu4Cz3s+PnDnwgSru2K1bo6Yg4Rl8NiyNtoijXeDU/CC1Yk39sa4WcphokmEeou+rC3CQ0vbiJiKjNcYT0/nPR9Xw/q+OLf0yYXdyPoSFo8tbyfZQCPogqexfZ/rumNsWiyrw0TzCL3+c1VHlAevaCNqUPcXeM718TTc2hfnzoUJubCbwKKkxWPL20hFDKZcv67nYGzPx/Z91nTH+PSSlOwfJppKxcccX6pjaYdnjqfJuj5J08CqowlKX2uyro9hKO7sT3BLX1yCpckM5Vy2H0szUfBImAaROup/waqw4LK7oScYsUiwiGZTtXCB4AJ//kSG01kXSynipqr5i3jBC5Ybd0QMNi5OsqpT5lia1bjt8cKJDMczDgpFsg76n+MHT98nLYM7+hNc3xOreZuEqIaqhgsED4W9OZznjeEctqdrNorxi3eLCljVGWXjoiQpWRXW9HyteW/U5vWhHDnXJ16jUUxptKLRLGuLcN/iFF0x2dpFNK+qh0vJ9FGMqRQxU2HOwx2b1hrbD1bjlEYr13RE5W6xxUwfxaAVCVPNy7MkurhPne3r8mhlXU9MymCi6c1buEAwitkzkuedkTzp4jnJMdMgogj9xd71NfninWLMVFzdGeXOfhmttLLSKObN4TyTTrDYJGoookb45TJPB/3P15qIoVjRHuGuhUkZrYiWMa/hUlLwNEcmC7w3ZnM66+JqTUQpIobCnGPQaK3xCUKl4GuUUnRGDdZ1x1jdFZMHI0WZ52s+mHJ4byzPxxkXx9dYKgiZufY/CMLLKfU/oC1isKY7xrVdMQkV0XJqEi4lWmtO5zz2j9kcmihQmLZ9h0JhGWAphVIw/XLXgNbB3aGrOfs5ShFRcEVbhHXdMZa3R+al9CYa10jeZf+YzYGJAnk32DQSLt7/0OBpcPW0z1EKS8HChMXanhgrO6J1tUpNiPlU03CZzvE1I3mPkbzLSN7jVNZlrODh+VDajlDr4Ez74n+YCtojBguTFn3x4PCyvrhJQk7uExVyfc2o7RX7oMfpXNAPXV8HNzPM3v+SlsHChMWChElv3KQ3bpGyar8qTYhaq5twmU3B04wXggvc1UE5w1DBCX2WEZS9JEhEtbi+Ztz2KBT7n+9r1LT+1xYxJEiEOI+6DhchhBCNSW77hRBChE7CRQghROgkXIQQQoROwkUIIUToJFyEEEKETsJFCCFE6CRchBBChE7CRQghROgkXIQQQoROwkUIIUTo/n+q+qL83tQ4OwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Input a csv file with the edges in the graph with the columns: node_1,node_2,time_lag\n", "file_path = \"../../docs/source/example_notebooks/datasets/temporal_graph.csv\"\n", @@ -90,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -99,20 +79,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(['V5', 'V7'], [1.0, 3.0])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# read the dataframe in a csv format from the user\n", "dataset_path=\"../../docs/source/example_notebooks/datasets/temporal_dataset.csv\"\n", @@ -128,132 +97,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
V1V2V3V4V5V6V7V5_lag1V7_lag1V7_lag2V7_lag3
012345670000
123456785700
234567896870
3456789107987
4015789781098
\n", - "
" - ], - "text/plain": [ - " V1 V2 V3 V4 V5 V6 V7 V5_lag1 V7_lag1 V7_lag2 V7_lag3\n", - "0 1 2 3 4 5 6 7 0 0 0 0\n", - "1 2 3 4 5 6 7 8 5 7 0 0\n", - "2 3 4 5 6 7 8 9 6 8 7 0\n", - "3 4 5 6 7 8 9 10 7 9 8 7\n", - "4 0 1 5 7 8 9 7 8 10 9 8" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "time_shifted_df = shift_columns(dataframe,parents[0],parents[1])\n", "time_shifted_df.head()" @@ -261,108 +107,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
V6V5V5_lag1V7V7_lag1V7_lag2V7_lag3
06507000
17658700
28769870
398710987
498871098
\n", - "
" - ], - "text/plain": [ - " V6 V5 V5_lag1 V7 V7_lag1 V7_lag2 V7_lag3\n", - "0 6 5 0 7 0 0 0\n", - "1 7 6 5 8 7 0 0\n", - "2 8 7 6 9 8 7 0\n", - "3 9 8 7 10 9 8 7\n", - "4 9 8 8 7 10 9 8" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "filtered_ts_df = _filter_columns(time_shifted_df,target_node,parents[0])\n", "filtered_ts_df.head()" @@ -379,47 +126,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "*** Causal Estimate ***\n", - "\n", - "## Identified estimand\n", - "Estimand type: EstimandType.NONPARAMETRIC_ATE\n", - "\n", - "### Estimand : 1\n", - "Estimand name: backdoor\n", - "Estimand expression:\n", - " d \n", - "─────(E[V₆])\n", - "d[V₅] \n", - "Estimand assumption 1, Unconfoundedness: If U→{V5} and U→V6 then P(V6|V5,,U) = P(V6|V5,)\n", - "\n", - "## Realized estimand\n", - "b: V6~V5\n", - "Target units: ate\n", - "\n", - "## Estimate\n", - "Mean value: 0.39256198347107585\n", - "p-value: [0.04856244]\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/scipy/stats/_axis_nan_policy.py:531: UserWarning: kurtosistest only valid for n>=20 ... continuing anyway, n=10\n", - " res = hypotest_fun_out(*samples, **kwds)\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n" - ] - } - ], + "outputs": [], "source": [ "# perform causal effect estimation on this new dataset\n", "import dowhy\n", @@ -440,6 +149,20 @@ "\n", "print(estimate)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dowhy.utils.timeseries import create_graph_from_dot_format\n", + "\n", + "file_path = \"../../docs/source/example_notebooks/datasets/temporal_graph.dot\"\n", + "\n", + "graph = create_graph_from_dot_format(file_path)\n", + "plot(graph)\n" + ] } ], "metadata": { diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py index 7acd10e88..716baf0c8 100644 --- a/dowhy/utils/timeseries.py +++ b/dowhy/utils/timeseries.py @@ -83,19 +83,42 @@ def create_graph_from_csv(file_path:str) -> nx.DiGraph: return graph -def create_graph_from_dot_format(file_path:str) -> nx.DiGraph: +def create_graph_from_dot_format(file_path: str) -> nx.DiGraph: """ - Creates a directed graph from a DOT file. + Creates a directed graph from a DOT file and ensures it is a DiGraph. The DOT file should contain a graph in DOT format. :param file_path: The path to the DOT file. :type file_path: str - :return: A directed graph created from the DOT file. + :return: A directed graph (DiGraph) created from the DOT file. :rtype: nx.DiGraph """ - - # Read the DOT file into a graph - graph = nx.drawing.nx_agraph.read_dot(file_path) + # Read the DOT file into a MultiDiGraph + multi_graph = nx.drawing.nx_agraph.read_dot(file_path) + + # Initialize a new DiGraph + graph = nx.DiGraph() + # Iterate over edges of the MultiDiGraph + for u, v, data in multi_graph.edges(data=True): + if 'label' in data: + try: + time_lag = float(data['label']) + + # Handle multiple edges between the same nodes + if graph.has_edge(u, v): + existing_data = graph.get_edge_data(u, v) + if 'time_lag' in existing_data: + # Use maximum time_lag if multiple edges exist + existing_data['time_lag'] = max(existing_data['time_lag'], time_lag) + else: + existing_data['time_lag'] = time_lag + else: + graph.add_edge(u, v, time_lag=time_lag) + + except ValueError: + print(f"Invalid weight for the edge between {u} and {v}.") + return None + return graph \ No newline at end of file From 599419a52e7893766e214285968f511718346369 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 25 Jul 2024 10:07:07 +0000 Subject: [PATCH 24/67] tigramite support --- dowhy/timeseries/causal_effect_tutorial.ipynb | 90 +++++++++++++++++++ dowhy/utils/timeseries.py | 61 ++++++++++++- 2 files changed, 150 insertions(+), 1 deletion(-) diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index 652183b5a..423fd2279 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -163,6 +163,96 @@ "graph = create_graph_from_dot_format(file_path)\n", "plot(graph)\n" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Converting Tigramite Graph to a causal graph from the dataset\n", + "\n", + "Tigramite is a popular temporal causal discovery library. In this section, we highlight how the causal graph can be obtained by applying PCMCI+ algorithm from tigramite to obtain a temporal causal graph" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import tigramite\n", + "from tigramite import data_processing\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "# read the dataframe in a csv format from the user\n", + "dataset_path=\"../../docs/source/example_notebooks/datasets/temporal_dataset.csv\"\n", + "dataframe=pd.read_csv(dataset_path)\n", + "dataframe = dataframe.astype(float)\n", + "var_names = dataframe.columns\n", + "# convert the dataframe values to float\n", + "dataframe = tigramite.data_processing.DataFrame(dataframe.values, var_names=var_names)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from tigramite import plotting as tp\n", + "tp.plot_timeseries(dataframe, figsize=(15, 5)); plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from tigramite.pcmci import PCMCI\n", + "from tigramite.independence_tests.parcorr import ParCorr\n", + "import numpy as np\n", + "parcorr = ParCorr(significance='analytic')\n", + "pcmci = PCMCI(\n", + " dataframe=dataframe, \n", + " cond_ind_test=parcorr,\n", + " verbosity=1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "correlations = pcmci.run_bivci(tau_max=3, val_only=True)['val_matrix']\n", + "matrix_lags = np.argmax(np.abs(correlations), axis=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tau_max = 3\n", + "pc_alpha = None\n", + "pcmci.verbosity = 2\n", + "\n", + "results = pcmci.run_pcmciplus(tau_min=0, tau_max=tau_max, pc_alpha=pc_alpha)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dowhy.utils.timeseries import create_graph_from_array\n", + "\n", + "graph = create_graph_from_array(results['graph'], var_names)\n", + "\n", + "plot(graph)" + ] } ], "metadata": { diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py index 716baf0c8..b49166c86 100644 --- a/dowhy/utils/timeseries.py +++ b/dowhy/utils/timeseries.py @@ -121,4 +121,63 @@ def create_graph_from_dot_format(file_path: str) -> nx.DiGraph: print(f"Invalid weight for the edge between {u} and {v}.") return None - return graph \ No newline at end of file + return graph + +import numpy as np +import networkx as nx + +def create_graph_from_array(array: np.ndarray, var_names: list) -> nx.DiGraph: + """ + Create a NetworkX directed graph from a numpy array with time lag information. + + The numpy array `array` has shape (n, n, tau) where: + - n is the number of variables + - tau is the number of time lags + + The list `var_names` contains the names of the variables. + + The resulting graph will be a directed graph with edge attributes indicating + the type of link based on the array values. + + :param array: A numpy array of shape (n, n, tau) representing the causal links. + :type array: np.ndarray + :param var_names: A list of variable names. + :type var_names: list + :return: A directed graph with edge attributes based on the array values. + :rtype: nx.DiGraph + """ + n = array.shape[0] # Number of variables + tau = array.shape[2] # Number of time lags + + # Initialize a directed graph + graph = nx.DiGraph() + + # Add nodes with names + graph.add_nodes_from(var_names) + + # Iterate over all pairs of nodes + for i in range(n): + for j in range(n): + if i == j: + continue # Skip self-loops + + # Check for contemporaneous links (tau = 0) + if array[i, j, 0] == '-->': + graph.add_edge(var_names[i], var_names[j], type='contemporaneous', direction='forward') + elif array[i, j, 0] == '<--': + graph.add_edge(var_names[j], var_names[i], type='contemporaneous', direction='backward') + elif array[i, j, 0] == 'o-o': + graph.add_edge(var_names[i], var_names[j], type='adjacency', style='circle') + graph.add_edge(var_names[j], var_names[i], type='adjacency', style='circle') + elif array[i, j, 0] == 'x-x': + graph.add_edge(var_names[i], var_names[j], type='conflicting', style='cross') + graph.add_edge(var_names[j], var_names[i], type='conflicting', style='cross') + + # Check for lagged links (tau > 0) + for t in range(1, tau): + if array[i, j, t] == '-->': + graph.add_edge(var_names[i], var_names[j], time_lag=t) + elif array[j, i, t] == '-->': + graph.add_edge(var_names[j], var_names[i], time_lag=t) + + return graph From 848d58c9cc788aa816fa732c99fd278a4478b6f0 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 26 Jul 2024 04:01:33 +0000 Subject: [PATCH 25/67] updated filter to be a hidden function --- dowhy/timeseries/temporal_shift.py | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 77640aff5..98f2d6bd3 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -1,6 +1,6 @@ import networkx as nx import pandas as pd -from typing import List, Tuple +from typing import List, Tuple, Optional def find_lagged_parent_nodes(graph:nx.DiGraph, node:str) -> Tuple[List[str], List[int]]: """ @@ -22,9 +22,10 @@ def find_lagged_parent_nodes(graph:nx.DiGraph, node:str) -> Tuple[List[str], Lis time_lags.append(edge_data['time_lag']) return parent_nodes, time_lags -def shift_columns(df: pd.DataFrame, columns: List[str], lag: List[int]) -> pd.DataFrame: +def shift_columns_by_lag(df: pd.DataFrame, columns: List[str], lag: List[int], filter: bool, child_node: Optional[int] = None) -> pd.DataFrame: """ Given a dataframe, a list of columns, and a list of time lags, this function shifts the columns in the dataframe by the corresponding time lags, creating a new unique column for each shifted version. + Optionally, it can filter the dataframe to keep only the columns of the child node, the parent nodes, and their shifted versions. :param df: The dataframe to shift. :type df: pandas.DataFrame @@ -32,7 +33,11 @@ def shift_columns(df: pd.DataFrame, columns: List[str], lag: List[int]) -> pd.Da :type columns: list :param lags: A list of time lags to shift the columns by. :type lags: list - :return: The dataframe with the columns shifted by the corresponding time lags. + :param filter: A boolean indicating whether to filter the dataframe to keep only relevant columns. + :type filter: bool + :param child_node: The child node to keep when filtering. + :type child_node: int, optional + :return: The dataframe with the columns shifted by the corresponding time lags and optionally filtered. :rtype: pandas.DataFrame """ if len(columns) != len(lag): @@ -45,11 +50,14 @@ def shift_columns(df: pd.DataFrame, columns: List[str], lag: List[int]) -> pd.Da new_column_name = f"{column}_lag{shift}" new_df[new_column_name] = new_df[column].shift(shift, axis=0, fill_value=0) + if filter and child_node is not None: + new_df = _filter_columns(new_df, child_node, columns) + return new_df def _filter_columns(df: pd.DataFrame, child_node: int, parent_nodes: List[int]) -> pd.DataFrame: """ - Given a dataframe, a target node, and a list of action/parent nodes, this function filters the dataframe to keep only the columns of the target node, the parent nodes, and their shifted versions. + Given a dataframe, a target node, and a list of action/parent nodes, this function filters the dataframe to keep only the columns of the child node, the parent nodes, and their shifted versions. :param df: The dataframe to filter. :type df: pandas.DataFrame From aa8221c04fd39b1f0b611b16a70d62bf8b14291d Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 26 Jul 2024 04:06:10 +0000 Subject: [PATCH 26/67] pdated notebook, corrections in data type --- dowhy/timeseries/causal_effect_tutorial.ipynb | 16 +++------------- dowhy/timeseries/temporal_shift.py | 4 ++-- 2 files changed, 5 insertions(+), 15 deletions(-) diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index 423fd2279..d76ad7352 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -74,7 +74,7 @@ "metadata": {}, "outputs": [], "source": [ - "from dowhy.timeseries.temporal_shift import find_lagged_parent_nodes,shift_columns,_filter_columns" + "from dowhy.timeseries.temporal_shift import find_lagged_parent_nodes,shift_columns_by_lag,_filter_columns" ] }, { @@ -101,20 +101,10 @@ "metadata": {}, "outputs": [], "source": [ - "time_shifted_df = shift_columns(dataframe,parents[0],parents[1])\n", + "time_shifted_df = shift_columns_by_lag(dataframe,parents[0],parents[1],filter=True, child_node=target_node)\n", "time_shifted_df.head()" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "filtered_ts_df = _filter_columns(time_shifted_df,target_node,parents[0])\n", - "filtered_ts_df.head()" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -135,7 +125,7 @@ "from dowhy import CausalModel\n", "\n", "model = CausalModel(\n", - " data=filtered_ts_df,\n", + " data=time_shifted_df,\n", " treatment='V5',\n", " outcome='V6',\n", " proceed_when_unidentifiable=True # Proceed even if the causal graph is not fully identifiable\n", diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 98f2d6bd3..6ccd70a21 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -22,7 +22,7 @@ def find_lagged_parent_nodes(graph:nx.DiGraph, node:str) -> Tuple[List[str], Lis time_lags.append(edge_data['time_lag']) return parent_nodes, time_lags -def shift_columns_by_lag(df: pd.DataFrame, columns: List[str], lag: List[int], filter: bool, child_node: Optional[int] = None) -> pd.DataFrame: +def shift_columns_by_lag(df: pd.DataFrame, columns: List[str], lag: List[int], filter: bool, child_node: Optional[str] = None) -> pd.DataFrame: """ Given a dataframe, a list of columns, and a list of time lags, this function shifts the columns in the dataframe by the corresponding time lags, creating a new unique column for each shifted version. Optionally, it can filter the dataframe to keep only the columns of the child node, the parent nodes, and their shifted versions. @@ -55,7 +55,7 @@ def shift_columns_by_lag(df: pd.DataFrame, columns: List[str], lag: List[int], f return new_df -def _filter_columns(df: pd.DataFrame, child_node: int, parent_nodes: List[int]) -> pd.DataFrame: +def _filter_columns(df: pd.DataFrame, child_node: str, parent_nodes: List[str]) -> pd.DataFrame: """ Given a dataframe, a target node, and a list of action/parent nodes, this function filters the dataframe to keep only the columns of the child node, the parent nodes, and their shifted versions. From 0690fe5f423d64b7914265de594e52f93075a996 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 26 Jul 2024 04:09:24 +0000 Subject: [PATCH 27/67] better readability of parents and time lags --- dowhy/timeseries/causal_effect_tutorial.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/dowhy/timeseries/causal_effect_tutorial.ipynb index d76ad7352..531a94801 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/dowhy/timeseries/causal_effect_tutorial.ipynb @@ -91,8 +91,8 @@ "target_node = 'V6'\n", "\n", "# find the action nodes of the given target node with respective lag times\n", - "parents = find_lagged_parent_nodes(graph, target_node)\n", - "parents" + "parents, time_lags = find_lagged_parent_nodes(graph, target_node)\n", + "print (\"Parents of the target node with respective time lags: \", parents, time_lags)" ] }, { @@ -101,7 +101,7 @@ "metadata": {}, "outputs": [], "source": [ - "time_shifted_df = shift_columns_by_lag(dataframe,parents[0],parents[1],filter=True, child_node=target_node)\n", + "time_shifted_df = shift_columns_by_lag(dataframe,parents,time_lags,filter=True, child_node=target_node)\n", "time_shifted_df.head()" ] }, From 41d32467665b6c59c6a4e3be448ff1f589ea6869 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 26 Jul 2024 04:19:55 +0000 Subject: [PATCH 28/67] graph creation test --- dowhy/timeseries/tests/graph_test.py | 67 ++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 dowhy/timeseries/tests/graph_test.py diff --git a/dowhy/timeseries/tests/graph_test.py b/dowhy/timeseries/tests/graph_test.py new file mode 100644 index 000000000..8aa3c9254 --- /dev/null +++ b/dowhy/timeseries/tests/graph_test.py @@ -0,0 +1,67 @@ +import unittest +import networkx as nx +import pandas as pd +import numpy as np +from io import StringIO +from dowhy.utils.timeseries import create_graph_from_user, create_graph_from_csv, create_graph_from_dot_format, create_graph_from_array + +# Import the functions from your module +# from your_module import create_graph_from_user, create_graph_from_csv, create_graph_from_dot_format, create_graph_from_array + +class TestGraphFunctions(unittest.TestCase): + + def test_create_graph_from_csv(self): + csv_content = """node1,node2,time_lag +A,B,5 +B,C,2 +A,C,7""" + df = pd.read_csv(StringIO(csv_content)) + df.to_csv("test.csv", index=False) + + graph = create_graph_from_csv("test.csv") + + self.assertIsInstance(graph, nx.DiGraph) + self.assertEqual(len(graph.edges()), 3) + self.assertEqual(graph['A']['B']['time_lag'], 5) + self.assertEqual(graph['B']['C']['time_lag'], 2) + self.assertEqual(graph['A']['C']['time_lag'], 7) + + def test_create_graph_from_dot_format(self): + dot_content = """digraph G { +A -> B [label="5"]; +B -> C [label="2"]; +A -> C [label="7"]; +}""" + with open("test.dot", "w") as f: + f.write(dot_content) + + graph = create_graph_from_dot_format("test.dot") + + self.assertIsInstance(graph, nx.DiGraph) + self.assertEqual(len(graph.edges()), 3) + self.assertEqual(graph['A']['B']['time_lag'], 5) + self.assertEqual(graph['B']['C']['time_lag'], 2) + self.assertEqual(graph['A']['C']['time_lag'], 7) + + def test_create_graph_from_array(self): + array = np.zeros((3, 3, 2), dtype=object) + array[0, 1, 0] = '-->' + array[1, 2, 0] = '-->' + array[0, 1, 1] = '-->' + array[2, 0, 1] = '-->' + + var_names = ['X1', 'X2', 'X3'] + + graph = create_graph_from_array(array, var_names) + + self.assertIsInstance(graph, nx.DiGraph) + self.assertEqual(len(graph.edges()), 3) + self.assertTrue(graph.has_edge('X1', 'X2')) + self.assertEqual(graph['X1']['X2']['type'], 'contemporaneous') + self.assertTrue(graph.has_edge('X1', 'X2')) + self.assertEqual(graph['X1']['X2']['time_lag'], 1) + self.assertTrue(graph.has_edge('X3', 'X1')) + self.assertEqual(graph['X3']['X1']['time_lag'], 1) + +if __name__ == '__main__': + unittest.main() From 7a3557f25fef7510d51a8fa87b3aa7065f0ef181 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 26 Jul 2024 10:52:17 +0000 Subject: [PATCH 29/67] removed wrong comment --- dowhy/timeseries/tests/graph_test.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/dowhy/timeseries/tests/graph_test.py b/dowhy/timeseries/tests/graph_test.py index 8aa3c9254..f3cfc1373 100644 --- a/dowhy/timeseries/tests/graph_test.py +++ b/dowhy/timeseries/tests/graph_test.py @@ -5,9 +5,6 @@ from io import StringIO from dowhy.utils.timeseries import create_graph_from_user, create_graph_from_csv, create_graph_from_dot_format, create_graph_from_array -# Import the functions from your module -# from your_module import create_graph_from_user, create_graph_from_csv, create_graph_from_dot_format, create_graph_from_array - class TestGraphFunctions(unittest.TestCase): def test_create_graph_from_csv(self): From 5e03ddcb7ba97e74f82a8390970a5a5533ee37e1 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 26 Jul 2024 10:57:02 +0000 Subject: [PATCH 30/67] moved test files --- .../timeseries/test_temporal_causal_graph_creation.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename dowhy/timeseries/tests/graph_test.py => tests/timeseries/test_temporal_causal_graph_creation.py (100%) diff --git a/dowhy/timeseries/tests/graph_test.py b/tests/timeseries/test_temporal_causal_graph_creation.py similarity index 100% rename from dowhy/timeseries/tests/graph_test.py rename to tests/timeseries/test_temporal_causal_graph_creation.py From 8ef07d0fb60dafe3265172cecc0051ceeb9c0598 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 26 Jul 2024 11:02:59 +0000 Subject: [PATCH 31/67] moved tutorial notebook & updated the path --- .../timeseries/causal_effect_tutorial.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) rename {dowhy => docs/source/example_notebooks}/timeseries/causal_effect_tutorial.ipynb (95%) diff --git a/dowhy/timeseries/causal_effect_tutorial.ipynb b/docs/source/example_notebooks/timeseries/causal_effect_tutorial.ipynb similarity index 95% rename from dowhy/timeseries/causal_effect_tutorial.ipynb rename to docs/source/example_notebooks/timeseries/causal_effect_tutorial.ipynb index 531a94801..42398cbb7 100644 --- a/dowhy/timeseries/causal_effect_tutorial.ipynb +++ b/docs/source/example_notebooks/timeseries/causal_effect_tutorial.ipynb @@ -50,7 +50,7 @@ "outputs": [], "source": [ "# Input a csv file with the edges in the graph with the columns: node_1,node_2,time_lag\n", - "file_path = \"../../docs/source/example_notebooks/datasets/temporal_graph.csv\"\n", + "file_path = \"../datasets/temporal_graph.csv\"\n", "\n", "# Create the graph from the CSV file\n", "graph = create_graph_from_csv(file_path)\n", @@ -84,7 +84,7 @@ "outputs": [], "source": [ "# read the dataframe in a csv format from the user\n", - "dataset_path=\"../../docs/source/example_notebooks/datasets/temporal_dataset.csv\"\n", + "dataset_path=\"../datasets/temporal_dataset.csv\"\n", "dataframe=pd.read_csv(dataset_path)\n", "\n", "# the node for which effect estimation has to be done, node:6\n", @@ -148,7 +148,7 @@ "source": [ "from dowhy.utils.timeseries import create_graph_from_dot_format\n", "\n", - "file_path = \"../../docs/source/example_notebooks/datasets/temporal_graph.dot\"\n", + "file_path = \"../datasets/temporal_graph.dot\"\n", "\n", "graph = create_graph_from_dot_format(file_path)\n", "plot(graph)\n" @@ -174,7 +174,7 @@ "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "# read the dataframe in a csv format from the user\n", - "dataset_path=\"../../docs/source/example_notebooks/datasets/temporal_dataset.csv\"\n", + "dataset_path=\"../datasets/temporal_dataset.csv\"\n", "dataframe=pd.read_csv(dataset_path)\n", "dataframe = dataframe.astype(float)\n", "var_names = dataframe.columns\n", From a2785e6ebdfea9de6fd3683a160f47c6bfd07398 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Sat, 27 Jul 2024 05:40:09 +0000 Subject: [PATCH 32/67] removed repeated imports --- dowhy/utils/timeseries.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py index b49166c86..692a6a37a 100644 --- a/dowhy/utils/timeseries.py +++ b/dowhy/utils/timeseries.py @@ -1,3 +1,4 @@ +import numpy as np import networkx as nx import pandas as pd @@ -123,8 +124,6 @@ def create_graph_from_dot_format(file_path: str) -> nx.DiGraph: return graph -import numpy as np -import networkx as nx def create_graph_from_array(array: np.ndarray, var_names: list) -> nx.DiGraph: """ From 8422ac68f5a09b9faa8bc538bec54bc739c3b1af Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Sat, 27 Jul 2024 12:42:02 +0000 Subject: [PATCH 33/67] time_lag parameter explained --- dowhy/utils/timeseries.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py index 692a6a37a..de2e2f01b 100644 --- a/dowhy/utils/timeseries.py +++ b/dowhy/utils/timeseries.py @@ -6,6 +6,8 @@ def create_graph_from_user() -> nx.DiGraph: """ Creates a directed graph based on user input from the console. + The time_lag parameter of the networkx graph represents the maximal causal lag of an edge between any 2 nodes in the graph. + The user is prompted to enter edges one by one in the format 'node1 node2 time_lag', where 'node1' and 'node2' are the nodes connected by the edge, and 'time_lag' is a numerical value representing the weight of the edge. The user should enter 'done' to finish inputting edges. @@ -48,6 +50,8 @@ def create_graph_from_csv(file_path:str) -> nx.DiGraph: """ Creates a directed graph from a CSV file. + The time_lag parameter of the networkx graph represents the maximal causal lag of an edge between any 2 nodes in the graph. + The CSV file should have at least three columns: 'node1', 'node2', and 'time_lag'. Each row represents an edge from 'node1' to 'node2' with a 'time_lag' attribute. @@ -87,6 +91,8 @@ def create_graph_from_csv(file_path:str) -> nx.DiGraph: def create_graph_from_dot_format(file_path: str) -> nx.DiGraph: """ Creates a directed graph from a DOT file and ensures it is a DiGraph. + + The time_lag parameter of the networkx graph represents the maximal causal lag of an edge between any 2 nodes in the graph. The DOT file should contain a graph in DOT format. @@ -125,15 +131,11 @@ def create_graph_from_dot_format(file_path: str) -> nx.DiGraph: return graph -def create_graph_from_array(array: np.ndarray, var_names: list) -> nx.DiGraph: +def create_graph_from_networkx_array(array: np.ndarray, var_names: list) -> nx.DiGraph: """ Create a NetworkX directed graph from a numpy array with time lag information. - The numpy array `array` has shape (n, n, tau) where: - - n is the number of variables - - tau is the number of time lags - - The list `var_names` contains the names of the variables. + The time_lag parameter of the networkx graph represents the maximal causal lag of an edge between any 2 nodes in the graph. The resulting graph will be a directed graph with edge attributes indicating the type of link based on the array values. From e2813c8cc2618f809a4bcd9f2186e5e130038671 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Sat, 27 Jul 2024 12:46:40 +0000 Subject: [PATCH 34/67] better function name --- dowhy/timeseries/temporal_shift.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 6ccd70a21..5b3080c16 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -2,7 +2,7 @@ import pandas as pd from typing import List, Tuple, Optional -def find_lagged_parent_nodes(graph:nx.DiGraph, node:str) -> Tuple[List[str], List[int]]: +def find_lagged_parents(graph:nx.DiGraph, node:str) -> Tuple[List[str], List[int]]: """ Given a graph and a node, this function returns the parent nodes of the node and the time lags associated with the edges between the parent nodes and the node. From 19d53e2d743908469acb2fea6e032454bafc6aa7 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Sat, 27 Jul 2024 12:49:00 +0000 Subject: [PATCH 35/67] updated imports --- .../timeseries/causal_effect_tutorial.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/source/example_notebooks/timeseries/causal_effect_tutorial.ipynb b/docs/source/example_notebooks/timeseries/causal_effect_tutorial.ipynb index 42398cbb7..94374af65 100644 --- a/docs/source/example_notebooks/timeseries/causal_effect_tutorial.ipynb +++ b/docs/source/example_notebooks/timeseries/causal_effect_tutorial.ipynb @@ -74,7 +74,7 @@ "metadata": {}, "outputs": [], "source": [ - "from dowhy.timeseries.temporal_shift import find_lagged_parent_nodes,shift_columns_by_lag,_filter_columns" + "from dowhy.timeseries.temporal_shift import find_lagged_parents,shift_columns_by_lag,_filter_columns" ] }, { @@ -91,7 +91,7 @@ "target_node = 'V6'\n", "\n", "# find the action nodes of the given target node with respective lag times\n", - "parents, time_lags = find_lagged_parent_nodes(graph, target_node)\n", + "parents, time_lags = find_lagged_parents(graph, target_node)\n", "print (\"Parents of the target node with respective time lags: \", parents, time_lags)" ] }, @@ -237,9 +237,9 @@ "metadata": {}, "outputs": [], "source": [ - "from dowhy.utils.timeseries import create_graph_from_array\n", + "from dowhy.utils.timeseries import create_graph_from_networkx_array\n", "\n", - "graph = create_graph_from_array(results['graph'], var_names)\n", + "graph = create_graph_from_networkx_array(results['graph'], var_names)\n", "\n", "plot(graph)" ] From 38f088387a9add2fc64c7bc9de9e2ab5cde2bf7c Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Sat, 27 Jul 2024 13:28:04 +0000 Subject: [PATCH 36/67] tests for temporal shift --- tests/timeseries/test_temporal_shift.py | 94 +++++++++++++++++++++++++ 1 file changed, 94 insertions(+) create mode 100644 tests/timeseries/test_temporal_shift.py diff --git a/tests/timeseries/test_temporal_shift.py b/tests/timeseries/test_temporal_shift.py new file mode 100644 index 000000000..49c54b653 --- /dev/null +++ b/tests/timeseries/test_temporal_shift.py @@ -0,0 +1,94 @@ +import unittest +import pandas as pd +from typing import List, Optional + +from dowhy.timeseries.temporal_shift import shift_columns_by_lag + +class TestShiftColumnsByLag(unittest.TestCase): + + def test_shift_columns_by_lag_basic_shift(self): + df = pd.DataFrame({ + 'A': [1, 2, 3, 4, 5], + 'B': [5, 4, 3, 2, 1] + }) + columns = ['A', 'B'] + lag = [2, 2] + result = shift_columns_by_lag(df, columns, lag, filter=False) + + expected = pd.DataFrame({ + 'A': [1, 2, 3, 4, 5], + 'B': [5, 4, 3, 2, 1], + 'A_lag1': [0, 1, 2, 3, 4], + 'A_lag2': [0, 0, 1, 2, 3], + 'B_lag1': [0, 5, 4, 3, 2], + 'B_lag2': [0, 0, 5, 4, 3] + }) + + pd.testing.assert_frame_equal(result, expected) + + def test_shift_columns_by_lag_different_lags(self): + df = pd.DataFrame({ + 'A': [1, 2, 3, 4, 5], + 'B': [5, 4, 3, 2, 1] + }) + columns = ['A', 'B'] + lag = [1, 3] + result = shift_columns_by_lag(df, columns, lag, filter=False) + + expected = pd.DataFrame({ + 'A': [1, 2, 3, 4, 5], + 'B': [5, 4, 3, 2, 1], + 'A_lag1': [0, 1, 2, 3, 4], + 'B_lag1': [0, 5, 4, 3, 2], + 'B_lag2': [0, 0, 5, 4, 3], + 'B_lag3': [0, 0, 0, 5, 4] + }) + + pd.testing.assert_frame_equal(result, expected) + + def test_shift_columns_by_lag_with_filter(self): + df = pd.DataFrame({ + 'A': [1, 2, 3, 4, 5], + 'B': [5, 4, 3, 2, 1], + 'C': [1, 1, 1, 1, 1] + }) + columns = ['A', 'B'] + lag = [1, 2] + result = shift_columns_by_lag(df, columns, lag, filter=True, child_node='C') + + expected = pd.DataFrame({ + 'C': [1, 1, 1, 1, 1], + 'A': [1, 2, 3, 4, 5], + 'B': [5, 4, 3, 2, 1], + 'A_lag1': [0, 1, 2, 3, 4], + 'B_lag1': [0, 5, 4, 3, 2], + 'B_lag2': [0, 0, 5, 4, 3] + }) + + pd.testing.assert_frame_equal(result, expected) + + def test_shift_columns_by_lag_empty_dataframe(self): + df = pd.DataFrame(columns=['A', 'B']) + columns = ['A', 'B'] + lag = [2, 2] + result = shift_columns_by_lag(df, columns, lag, filter=False) + + expected = pd.DataFrame(columns=['A', 'B', 'A_lag1', 'A_lag2', 'B_lag1', 'B_lag2']) + + pd.testing.assert_frame_equal(result, expected) + + def test_shift_columns_by_lag_unequal_columns_and_lags(self): + df = pd.DataFrame({ + 'A': [1, 2, 3, 4, 5], + 'B': [5, 4, 3, 2, 1] + }) + columns = ['A', 'B'] + lag = [1] + + with self.assertRaises(ValueError) as context: + shift_columns_by_lag(df, columns, lag, filter=False) + + self.assertTrue("The size of 'columns' and 'lag' lists must be the same." in str(context.exception)) + +if __name__ == '__main__': + unittest.main() From 4cd5edeb2ef01279a222189a95d568a6b7b8add6 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Sat, 27 Jul 2024 13:28:40 +0000 Subject: [PATCH 37/67] removed filter_columns function --- dowhy/timeseries/temporal_shift.py | 28 +++------------------------- 1 file changed, 3 insertions(+), 25 deletions(-) diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 5b3080c16..72e95ed2f 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -51,30 +51,8 @@ def shift_columns_by_lag(df: pd.DataFrame, columns: List[str], lag: List[int], f new_df[new_column_name] = new_df[column].shift(shift, axis=0, fill_value=0) if filter and child_node is not None: - new_df = _filter_columns(new_df, child_node, columns) + relevant_columns = [child_node] + columns + [f"{col}_lag{shift}" for col in columns for shift in range(1, lag[columns.index(col)] + 1)] + relevant_columns = list(dict.fromkeys(relevant_columns)) # Ensure unique and maintain order + new_df = new_df[relevant_columns] return new_df - -def _filter_columns(df: pd.DataFrame, child_node: str, parent_nodes: List[str]) -> pd.DataFrame: - """ - Given a dataframe, a target node, and a list of action/parent nodes, this function filters the dataframe to keep only the columns of the child node, the parent nodes, and their shifted versions. - - :param df: The dataframe to filter. - :type df: pandas.DataFrame - :param child_node: The child node. - :type child_node: int - :param parent_nodes: A list of parent nodes. - :type parent_nodes: list - :return: The dataframe with only the columns of the child node, parent nodes, and their shifted versions. - :rtype: pandas.DataFrame - """ - columns_to_keep = [str(child_node)] - for node in parent_nodes: - columns_to_keep.append(str(node)) - # Include all shifted versions of the parent node - shifted_columns = [col for col in df.columns if col.startswith(f"{node}_lag")] - columns_to_keep.extend(shifted_columns) - - # Filter the dataframe to keep only the relevant columns - filtered_df = df[columns_to_keep] - return filtered_df \ No newline at end of file From f518c09bd93981b4d7ec41029a372ceb10887284 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Mon, 29 Jul 2024 12:25:21 +0000 Subject: [PATCH 38/67] black and isort utils --- dowhy/utils/plotting.py | 3 +- dowhy/utils/timeseries.py | 93 +++++++++++++++++++++------------------ 2 files changed, 52 insertions(+), 44 deletions(-) diff --git a/dowhy/utils/plotting.py b/dowhy/utils/plotting.py index f71de34e9..44779f276 100644 --- a/dowhy/utils/plotting.py +++ b/dowhy/utils/plotting.py @@ -200,6 +200,7 @@ def _plot_as_pyplot_figure(pygraphviz_graph: Any, figure_size: Optional[Tuple[in if figure_size is not None: plt.rcParams["figure.figsize"] = org_fig_size + def pretty_print_graph(graph: nx.DiGraph) -> None: """ Pretty print the graph edges with time lags. @@ -211,4 +212,4 @@ def pretty_print_graph(graph: nx.DiGraph) -> None: """ print("\nGraph edges with time lags:") for edge in graph.edges(data=True): - print(f"{edge[0]} -> {edge[1]} with time-lagged dependency {edge[2]['time_lag']}") \ No newline at end of file + print(f"{edge[0]} -> {edge[1]} with time-lagged dependency {edge[2]['time_lag']}") diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py index de2e2f01b..99e0b4d79 100644 --- a/dowhy/utils/timeseries.py +++ b/dowhy/utils/timeseries.py @@ -1,7 +1,8 @@ -import numpy as np import networkx as nx +import numpy as np import pandas as pd + def create_graph_from_user() -> nx.DiGraph: """ Creates a directed graph based on user input from the console. @@ -22,11 +23,11 @@ def create_graph_from_user() -> nx.DiGraph: """ # Initialize an empty directed graph graph = nx.DiGraph() - + # Instructions for the user print("Enter the graph as a list of edges with time lags. Enter 'done' when you are finished.") print("Each edge should be entered in the format 'node1 node2 time_lag'. For example: 'A B 4'") - + # Loop to receive user input while True: edge = input("Enter an edge: ") @@ -43,10 +44,11 @@ def create_graph_from_user() -> nx.DiGraph: print("Invalid weight. Please enter a numerical value for the time_lag.") continue graph.add_edge(node1, node2, time_lag=time_lag) - + return graph -def create_graph_from_csv(file_path:str) -> nx.DiGraph: + +def create_graph_from_csv(file_path: str) -> nx.DiGraph: """ Creates a directed graph from a CSV file. @@ -62,7 +64,7 @@ def create_graph_from_csv(file_path:str) -> nx.DiGraph: Example: Example CSV content: - + .. code-block:: csv node1,node2,time_lag @@ -72,30 +74,35 @@ def create_graph_from_csv(file_path:str) -> nx.DiGraph: """ # Read the CSV file into a DataFrame df = pd.read_csv(file_path) - + # Initialize an empty directed graph graph = nx.DiGraph() - + # Add edges with time lag to the graph for index, row in df.iterrows(): # add validation for the time lag column to be a number try: - row['time_lag'] = float(row['time_lag']) + row["time_lag"] = float(row["time_lag"]) except ValueError: - print("Invalid weight. Please enter a numerical value for the time_lag for the edge between {} and {}.".format(row['node1'], row['node2'])) + print( + "Invalid weight. Please enter a numerical value for the time_lag for the edge between {} and {}.".format( + row["node1"], row["node2"] + ) + ) return None - graph.add_edge(row['node1'], row['node2'], time_lag=row['time_lag']) - + graph.add_edge(row["node1"], row["node2"], time_lag=row["time_lag"]) + return graph + def create_graph_from_dot_format(file_path: str) -> nx.DiGraph: """ Creates a directed graph from a DOT file and ensures it is a DiGraph. The time_lag parameter of the networkx graph represents the maximal causal lag of an edge between any 2 nodes in the graph. - + The DOT file should contain a graph in DOT format. - + :param file_path: The path to the DOT file. :type file_path: str :return: A directed graph (DiGraph) created from the DOT file. @@ -103,27 +110,27 @@ def create_graph_from_dot_format(file_path: str) -> nx.DiGraph: """ # Read the DOT file into a MultiDiGraph multi_graph = nx.drawing.nx_agraph.read_dot(file_path) - + # Initialize a new DiGraph graph = nx.DiGraph() - + # Iterate over edges of the MultiDiGraph for u, v, data in multi_graph.edges(data=True): - if 'label' in data: + if "label" in data: try: - time_lag = float(data['label']) - + time_lag = float(data["label"]) + # Handle multiple edges between the same nodes if graph.has_edge(u, v): existing_data = graph.get_edge_data(u, v) - if 'time_lag' in existing_data: + if "time_lag" in existing_data: # Use maximum time_lag if multiple edges exist - existing_data['time_lag'] = max(existing_data['time_lag'], time_lag) + existing_data["time_lag"] = max(existing_data["time_lag"], time_lag) else: - existing_data['time_lag'] = time_lag + existing_data["time_lag"] = time_lag else: graph.add_edge(u, v, time_lag=time_lag) - + except ValueError: print(f"Invalid weight for the edge between {u} and {v}.") return None @@ -134,12 +141,12 @@ def create_graph_from_dot_format(file_path: str) -> nx.DiGraph: def create_graph_from_networkx_array(array: np.ndarray, var_names: list) -> nx.DiGraph: """ Create a NetworkX directed graph from a numpy array with time lag information. - + The time_lag parameter of the networkx graph represents the maximal causal lag of an edge between any 2 nodes in the graph. - + The resulting graph will be a directed graph with edge attributes indicating the type of link based on the array values. - + :param array: A numpy array of shape (n, n, tau) representing the causal links. :type array: np.ndarray :param var_names: A list of variable names. @@ -149,36 +156,36 @@ def create_graph_from_networkx_array(array: np.ndarray, var_names: list) -> nx.D """ n = array.shape[0] # Number of variables tau = array.shape[2] # Number of time lags - + # Initialize a directed graph graph = nx.DiGraph() - + # Add nodes with names graph.add_nodes_from(var_names) - + # Iterate over all pairs of nodes for i in range(n): for j in range(n): if i == j: continue # Skip self-loops - + # Check for contemporaneous links (tau = 0) - if array[i, j, 0] == '-->': - graph.add_edge(var_names[i], var_names[j], type='contemporaneous', direction='forward') - elif array[i, j, 0] == '<--': - graph.add_edge(var_names[j], var_names[i], type='contemporaneous', direction='backward') - elif array[i, j, 0] == 'o-o': - graph.add_edge(var_names[i], var_names[j], type='adjacency', style='circle') - graph.add_edge(var_names[j], var_names[i], type='adjacency', style='circle') - elif array[i, j, 0] == 'x-x': - graph.add_edge(var_names[i], var_names[j], type='conflicting', style='cross') - graph.add_edge(var_names[j], var_names[i], type='conflicting', style='cross') - + if array[i, j, 0] == "-->": + graph.add_edge(var_names[i], var_names[j], type="contemporaneous", direction="forward") + elif array[i, j, 0] == "<--": + graph.add_edge(var_names[j], var_names[i], type="contemporaneous", direction="backward") + elif array[i, j, 0] == "o-o": + graph.add_edge(var_names[i], var_names[j], type="adjacency", style="circle") + graph.add_edge(var_names[j], var_names[i], type="adjacency", style="circle") + elif array[i, j, 0] == "x-x": + graph.add_edge(var_names[i], var_names[j], type="conflicting", style="cross") + graph.add_edge(var_names[j], var_names[i], type="conflicting", style="cross") + # Check for lagged links (tau > 0) for t in range(1, tau): - if array[i, j, t] == '-->': + if array[i, j, t] == "-->": graph.add_edge(var_names[i], var_names[j], time_lag=t) - elif array[j, i, t] == '-->': + elif array[j, i, t] == "-->": graph.add_edge(var_names[j], var_names[i], time_lag=t) return graph From 8b621bed789e0de67b354705a10def3bb6cb1ee9 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Mon, 29 Jul 2024 12:26:04 +0000 Subject: [PATCH 39/67] black and isort timeseries --- dowhy/timeseries/temporal_shift.py | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 72e95ed2f..03a70f356 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -1,8 +1,10 @@ +from typing import List, Optional, Tuple + import networkx as nx import pandas as pd -from typing import List, Tuple, Optional -def find_lagged_parents(graph:nx.DiGraph, node:str) -> Tuple[List[str], List[int]]: + +def find_lagged_parents(graph: nx.DiGraph, node: str) -> Tuple[List[str], List[int]]: """ Given a graph and a node, this function returns the parent nodes of the node and the time lags associated with the edges between the parent nodes and the node. @@ -17,12 +19,15 @@ def find_lagged_parents(graph:nx.DiGraph, node:str) -> Tuple[List[str], List[int time_lags = [] for n in graph.predecessors(node): edge_data = graph.get_edge_data(n, node) - if 'time_lag' in edge_data: + if "time_lag" in edge_data: parent_nodes.append(n) - time_lags.append(edge_data['time_lag']) + time_lags.append(edge_data["time_lag"]) return parent_nodes, time_lags -def shift_columns_by_lag(df: pd.DataFrame, columns: List[str], lag: List[int], filter: bool, child_node: Optional[str] = None) -> pd.DataFrame: + +def shift_columns_by_lag( + df: pd.DataFrame, columns: List[str], lag: List[int], filter: bool, child_node: Optional[str] = None +) -> pd.DataFrame: """ Given a dataframe, a list of columns, and a list of time lags, this function shifts the columns in the dataframe by the corresponding time lags, creating a new unique column for each shifted version. Optionally, it can filter the dataframe to keep only the columns of the child node, the parent nodes, and their shifted versions. @@ -42,17 +47,21 @@ def shift_columns_by_lag(df: pd.DataFrame, columns: List[str], lag: List[int], f """ if len(columns) != len(lag): raise ValueError("The size of 'columns' and 'lag' lists must be the same.") - + new_df = df.copy() for column, max_lag in zip(columns, lag): max_lag = int(max_lag) for shift in range(1, max_lag + 1): new_column_name = f"{column}_lag{shift}" new_df[new_column_name] = new_df[column].shift(shift, axis=0, fill_value=0) - + if filter and child_node is not None: - relevant_columns = [child_node] + columns + [f"{col}_lag{shift}" for col in columns for shift in range(1, lag[columns.index(col)] + 1)] + relevant_columns = ( + [child_node] + + columns + + [f"{col}_lag{shift}" for col in columns for shift in range(1, lag[columns.index(col)] + 1)] + ) relevant_columns = list(dict.fromkeys(relevant_columns)) # Ensure unique and maintain order new_df = new_df[relevant_columns] - + return new_df From 2f097ef7f1c902d7ad43ee3cd22c41343fa2e8ef Mon Sep 17 00:00:00 2001 From: Amit Sharma Date: Mon, 29 Jul 2024 19:29:43 +0530 Subject: [PATCH 40/67] updated notebook text Signed-off-by: Amit Sharma --- ...=> effect_inference_timeseries_data.ipynb} | 104 +++++++++++------- 1 file changed, 63 insertions(+), 41 deletions(-) rename docs/source/example_notebooks/timeseries/{causal_effect_tutorial.ipynb => effect_inference_timeseries_data.ipynb} (74%) diff --git a/docs/source/example_notebooks/timeseries/causal_effect_tutorial.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb similarity index 74% rename from docs/source/example_notebooks/timeseries/causal_effect_tutorial.ipynb rename to docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index 94374af65..12e24ec9a 100644 --- a/docs/source/example_notebooks/timeseries/causal_effect_tutorial.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -4,16 +4,28 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Temporal Causal Inference\n", + "# Effect inference with timeseries data\n", "\n", - "In this notebook, we will look at an example of causal effect inference for Temporal Dependencies within a Graphical Causal Model. We demonstrate the use of temporal shift to normalise temporal datasets and establish causal effects." + "In this notebook, we will look at an example of causal effect inference from timeseries data. We will use DoWhy's functionality to add temporal dependencies to a causal graph and estimate causal effect based on the augmented graph. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import networkx as nx\n", + "import pandas as pd\n", + "from dowhy.utils.timeseries import create_graph_from_csv,create_graph_from_user\n", + "from dowhy.utils.plotting import plot, pretty_print_graph" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Estimating the lag between the parent and action node is quite challenging in temporal causal inference. In this tutorial, we will assume we have the ground truth causal graph as an input." + "## Loading timeseries data and causal graph" ] }, { @@ -22,17 +34,39 @@ "metadata": {}, "outputs": [], "source": [ - "import networkx as nx\n", - "import pandas as pd\n", - "from dowhy.utils.timeseries import create_graph_from_csv,create_graph_from_user\n", - "from dowhy.utils.plotting import plot, pretty_print_graph" + "# read the dataframe in a csv format from the user\n", + "dataset_path=\"../datasets/temporal_dataset.csv\"\n", + "dataframe=pd.read_csv(dataset_path)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The user can create a csv file with the edges in the temporal graph. The columns in the csv are node_1, node_2, time_lag which represents an directed edge node_1 -> node_2 with the time lag of time_lag. Let us consider the following graph as the input\n", + "In temporal causal inference, accurately estimating causal effects often requires accounting for time lags between nodes in a graph. For instance, if $node_1$ influences $node_2$ with a time lag of 5 timestamps, we represent this dependency as $node_1(t-5)$ -> $node_2(t)$.\n", + "\n", + "We can provide the causal graph as a networkx DAG or as a dot file. The edge attributes should mention the maximum `time_lag` that is associated with each edge (if any)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dowhy.utils.timeseries import create_graph_from_dot_format\n", + "\n", + "file_path = \"../datasets/temporal_graph.dot\"\n", + "\n", + "graph = create_graph_from_dot_format(file_path)\n", + "plot(graph)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also create a csv file with the edges in the temporal graph. The columns in the csv are node1, node2, time_lag which represents an directed edge node1 -> node2 with the time lag of time_lag. Let us consider the following graph as the input:\n", "\n", "| node1 | node2 | time_lag |\n", "|--------|--------|----------|\n", @@ -63,9 +97,9 @@ "source": [ "## Dataset Shifting and Filtering\n", "\n", - "In temporal causal inference, accurately estimating causal effects often requires accounting for time lags between nodes in a graph. For instance, if node_1 influences node_2 with a time lag of 5 timestamps, we represent this dependency as node_1(t-5) -> node_2(t). To maintain this causal relationship in our analysis, we need to shift the columns by the given time lag.\n", + "To prepare the dataset for temporal causal inference, we need to shift the columns by the given time lag.\n", "\n", - "When considering node_2 as the target node, the data for node_1 should be shifted down by 5 timestamps. This adjustment ensures that the new edge node_1(t) -> node_2(t) accurately represents the same lagged dependency as before. Shifting the data in this manner aligns the time series data correctly, allowing us to properly analyze and estimate the causal effects." + "For example, in the causal graph above, $node_1(t-5)$ -> $node_2(t)$ with a lag of 3. When considering $node_2$ as the target node, the data for $node_1$ should be shifted down by 3 timestamps. This adjustment ensures that the edge $node_1$ -> $node_2$ accurately represents the lagged dependency. Shifting the data in this manner creates additional columns and allows downstream estimators to acccess the correct values in the same row of a dataframe. " ] }, { @@ -74,7 +108,7 @@ "metadata": {}, "outputs": [], "source": [ - "from dowhy.timeseries.temporal_shift import find_lagged_parents,shift_columns_by_lag,_filter_columns" + "from dowhy.timeseries.temporal_shift import find_lagged_parents,shift_columns_by_lag" ] }, { @@ -83,11 +117,7 @@ "metadata": {}, "outputs": [], "source": [ - "# read the dataframe in a csv format from the user\n", - "dataset_path=\"../datasets/temporal_dataset.csv\"\n", - "dataframe=pd.read_csv(dataset_path)\n", - "\n", - "# the node for which effect estimation has to be done, node:6\n", + "# the outcome node for which effect estimation has to be done, node:6\n", "target_node = 'V6'\n", "\n", "# find the action nodes of the given target node with respective lag times\n", @@ -95,6 +125,15 @@ "print (\"Parents of the target node with respective time lags: \", parents, time_lags)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "time_lags" + ] + }, { "cell_type": "code", "execution_count": null, @@ -109,7 +148,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Cause Estimation using Dowhy\n", + "## Causal Effect Estimation\n", "\n", "Once you have the new dataframe, causal effect estimation can be performed on the target node with respect to the action nodes." ] @@ -127,8 +166,7 @@ "model = CausalModel(\n", " data=time_shifted_df,\n", " treatment='V5',\n", - " outcome='V6',\n", - " proceed_when_unidentifiable=True # Proceed even if the causal graph is not fully identifiable\n", + " outcome='V6'\n", ")\n", "\n", "identified_estimand = model.identify_effect()\n", @@ -140,27 +178,13 @@ "print(estimate)" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from dowhy.utils.timeseries import create_graph_from_dot_format\n", - "\n", - "file_path = \"../datasets/temporal_graph.dot\"\n", - "\n", - "graph = create_graph_from_dot_format(file_path)\n", - "plot(graph)\n" - ] - }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Converting Tigramite Graph to a causal graph from the dataset\n", + "# Importing temporal causal graph from Tigramite library\n", "\n", - "Tigramite is a popular temporal causal discovery library. In this section, we highlight how the causal graph can be obtained by applying PCMCI+ algorithm from tigramite to obtain a temporal causal graph" + "Tigramite is a popular temporal causal discovery library. In this section, we highlight how the causal graph can be obtained by applying PCMCI+ algorithm from tigramite and imported into DoWhy." ] }, { @@ -173,9 +197,7 @@ "from tigramite import data_processing\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", - "# read the dataframe in a csv format from the user\n", - "dataset_path=\"../datasets/temporal_dataset.csv\"\n", - "dataframe=pd.read_csv(dataset_path)\n", + "\n", "dataframe = dataframe.astype(float)\n", "var_names = dataframe.columns\n", "# convert the dataframe values to float\n", @@ -247,7 +269,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -261,9 +283,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.14" + "version": "3.8.10" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From 559e1fb9a846e5003101996ec2611cbc8ec27ef4 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Tue, 30 Jul 2024 02:58:09 +0000 Subject: [PATCH 41/67] integer range fix --- dowhy/timeseries/temporal_shift.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 03a70f356..903fef2a1 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -59,7 +59,8 @@ def shift_columns_by_lag( relevant_columns = ( [child_node] + columns - + [f"{col}_lag{shift}" for col in columns for shift in range(1, lag[columns.index(col)] + 1)] + + [f"{col}_lag{shift}" for col in columns for shift in range(1, int + (lag[columns.index(col)]) + 1)] ) relevant_columns = list(dict.fromkeys(relevant_columns)) # Ensure unique and maintain order new_df = new_df[relevant_columns] From a52999de9260d5d4887093cdcea22164e3762ff5 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Tue, 30 Jul 2024 03:11:13 +0000 Subject: [PATCH 42/67] correction in timestamp : notebook text --- .../timeseries/effect_inference_timeseries_data.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index 12e24ec9a..0205bbb93 100644 --- a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -99,7 +99,7 @@ "\n", "To prepare the dataset for temporal causal inference, we need to shift the columns by the given time lag.\n", "\n", - "For example, in the causal graph above, $node_1(t-5)$ -> $node_2(t)$ with a lag of 3. When considering $node_2$ as the target node, the data for $node_1$ should be shifted down by 3 timestamps. This adjustment ensures that the edge $node_1$ -> $node_2$ accurately represents the lagged dependency. Shifting the data in this manner creates additional columns and allows downstream estimators to acccess the correct values in the same row of a dataframe. " + "For example, in the causal graph above, $node_1(t-3)$ -> $node_2(t)$ with a lag of 3. When considering $node_2$ as the target node, the data for $node_1$ should be shifted down by 3 timestamps. This adjustment ensures that the edge $node_1$ -> $node_2$ accurately represents the lagged dependency. Shifting the data in this manner creates additional columns and allows downstream estimators to acccess the correct values in the same row of a dataframe. " ] }, { From e3b8e22d5faf652379aaeaf8bda3b4786baba4c2 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Tue, 30 Jul 2024 03:23:24 +0000 Subject: [PATCH 43/67] time lagged causal estimation --- .../effect_inference_timeseries_data.ipynb | 5845 ++++++++++++++++- 1 file changed, 5818 insertions(+), 27 deletions(-) diff --git a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index 0205bbb93..26a9c82f4 100644 --- a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -11,9 +11,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], "source": [ "import networkx as nx\n", "import pandas as pd\n", @@ -30,7 +39,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -50,9 +59,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from dowhy.utils.timeseries import create_graph_from_dot_format\n", "\n", @@ -79,9 +99,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Input a csv file with the edges in the graph with the columns: node_1,node_2,time_lag\n", "file_path = \"../datasets/temporal_graph.csv\"\n", @@ -104,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -113,9 +144,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parents of the target node with respective time lags: ['V5', 'V7'] [1.0, 3.0]\n" + ] + } + ], "source": [ "# the outcome node for which effect estimation has to be done, node:6\n", "target_node = 'V6'\n", @@ -127,18 +166,132 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGAAAAAUCAYAAAByKzjvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAABJ0AAASdAHeZh94AAADX0lEQVR4nO2ZW4hOURTHfyNKbqPGZRIJGUoiKYSGFFJKeCQ8KCGSoVzqP4uEB+RaHtSkvHihpOTSjHJLSXkgl3EpQu7JpVzGw96H4zhnnG++880R/i/rnLX3Xvu/zl5nX9Yua2pq4j/yQ5u8CfzraBs8mNkEoD5UdlPS4NYm9LfCzLoBz8I6SWVtY+qeBRqA5xEDs4FqYDgwDOgMHJI0p4WEegMbgKlABfAYOAqYpFctsZmiz63ASKAK6AZ8AB74fvdIelGgvUJ8eA+Yf54P9IX4KahBUq2kPRH9emApbgAeFUI0hvgA4AqwALgM7ADuAsuBi2ZWUYz9ZrAC6AicAnYCh4DPQC1wzcz6pDVUqA+S3vvvWgvcD/Rxf0Bz5B8Cd3B/Qn3z1ZvFPqAHsEzS7kBpZtt9P5uARUXYT0IXSR+jSjPbBKwF1gCLU9rKxIfUi7Ckekm3JRW1bfKRMxkXBXuj3QDvgLlm1rGYfuIQ9/E9Dns5MI2dLH3IYxc00cuTkr6GCyS9Bc4DHYDRrchpupfXUtbPzIdCpqCsMMjLWwnlt3HRVQWcKQUBM6sBOgHluEV5HO7jb0lpIjMf8hiAci/fJJQH+q4l5FAD9Ay9nwDmS3qWUD+KzHz4Jw9ikiollQGVwEygP3DVzEa0Npc8BiCIjvKE8kD/utREJD2VdAQ3XVQAB1M2zcyHPAbgppdVCeXBTiRpfs0ckh4A14Eh/sT6O2TmQx4DEJwfJpvZT/2bWWdgLO7UeKmVefXy8kuKupn5UNJF2O+X2wGNkj4BSGo0s5O4334JsDvcBHdS3S/pXcRWHTAPWCCprgVcqoCnkt5E9G2AjbhD1YVoCiFLH+KQegDMbAYww79WejnGfxiA55JqIs3O4HIe/Qgdv3GnzQvALjObBNwARuH217eAdTEUgkj7nJZzBNOAzWZ2DrgHvMDthKpxi/ATYGFMuyx9+AWFTEHDcRE4D5jidf1DutlpDUlqxO2/63CkVwIDcPmZ0QlJsaHAW+B4AZzDOA0cALrjdj6rgFnAS1zUDpF0vcQ+/IKy4EImlI42nzD6Y2BmXXERu03S6pzpFA0zawCqk9LRMjPxZ90HjAc+AdvzJtJSxN0HwM9rwH1+5Kshch+QJyQdA9rnzaNIhO8DvuMbaYtJX5Gn7IQAAAAASUVORK5CYII=", + "text/latex": [ + "$\\displaystyle \\left[ 1.0, \\ 3.0\\right]$" + ], + "text/plain": [ + "[1.0, 3.0]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "time_lags" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
V6V5V7V5_lag1V7_lag1V7_lag2V7_lag3
06570000
17685700
28796870
398107987
498781098
\n", + "
" + ], + "text/plain": [ + " V6 V5 V7 V5_lag1 V7_lag1 V7_lag2 V7_lag3\n", + "0 6 5 7 0 0 0 0\n", + "1 7 6 8 5 7 0 0\n", + "2 8 7 9 6 8 7 0\n", + "3 9 8 10 7 9 8 7\n", + "4 9 8 7 8 10 9 8" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "time_shifted_df = shift_columns_by_lag(dataframe,parents,time_lags,filter=True, child_node=target_node)\n", "time_shifted_df.head()" @@ -155,9 +308,70 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "['V7', 'V7_lag1', 'V7_lag2', 'V7_lag3']" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "treatment = 'V7'\n", + "# Rename the lagged treatment columns to avoid ambiguity\n", + "treatment_columns = [treatment] + [f\"{treatment}_lag{i}\" for i in range(1, int(time_lags[parents.index(treatment)] + 1) ) ]\n", + "treatment_columns" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*** Causal Estimate ***\n", + "\n", + "## Identified estimand\n", + "Estimand type: EstimandType.NONPARAMETRIC_ATE\n", + "\n", + "### Estimand : 1\n", + "Estimand name: backdoor\n", + "Estimand expression:\n", + " d \n", + "───────────────────────────────────(E[V₆])\n", + "d[V₇ V_7_lag1 V_7_lag2 V_7_lag3] \n", + "Estimand assumption 1, Unconfoundedness: If U→{V7,V7_lag1,V7_lag2,V7_lag3} and U→V6 then P(V6|V7,V7_lag1,V7_lag2,V7_lag3,,U) = P(V6|V7,V7_lag1,V7_lag2,V7_lag3,)\n", + "\n", + "## Realized estimand\n", + "b: V6~V7+V7_lag1+V7_lag2+V7_lag3\n", + "Target units: ate\n", + "\n", + "## Estimate\n", + "Mean value: 0.19559790038471547\n", + "p-value: [0.48050704 0.04842794 0.98730841 0.40316486]\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/scipy/stats/_axis_nan_policy.py:531: UserWarning: kurtosistest only valid for n>=20 ... continuing anyway, n=10\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n" + ] + } + ], "source": [ "# perform causal effect estimation on this new dataset\n", "import dowhy\n", @@ -165,7 +379,7 @@ "\n", "model = CausalModel(\n", " data=time_shifted_df,\n", - " treatment='V5',\n", + " treatment=treatment_columns,\n", " outcome='V6'\n", ")\n", "\n", @@ -189,7 +403,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -206,9 +420,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from tigramite import plotting as tp\n", "tp.plot_timeseries(dataframe, figsize=(15, 5)); plt.show()" @@ -216,7 +441,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -232,9 +457,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "##\n", + "## Running Tigramite BivCI algorithm\n", + "##\n", + "\n", + "Parameters:\n", + "\n", + "independence test = par_corr\n", + "tau_min = 0\n", + "tau_max = 3\n" + ] + } + ], "source": [ "correlations = pcmci.run_bivci(tau_max=3, val_only=True)['val_matrix']\n", "matrix_lags = np.argmax(np.abs(correlations), axis=2)" @@ -242,9 +484,5547 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "##\n", + "## Optimizing pc_alpha over pc_alpha_list = [0.001, 0.005, 0.01, 0.025, 0.05]\n", + "##\n", + "\n", + "## pc_alpha = 0.001 (1/5):\n", + "\n", + "##\n", + "## Step 1: PC1 algorithm for selecting lagged conditions\n", + "##\n", + "\n", + "Parameters:\n", + "independence test = par_corr\n", + "tau_min = 1\n", + "tau_max = 3\n", + "pc_alpha = [0.001]\n", + "max_conds_dim = None\n", + "max_combinations = 1\n", + "\n", + "\n", + "\n", + "## Variable V1\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V1 (1/21):\n", + " Subset 0: () gives pval = 0.76612 / val = -0.234\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V1 (2/21):\n", + " Subset 0: () gives pval = 0.52792 / val = -0.472\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V1 (3/21):\n", + " Subset 0: () gives pval = 0.19791 / val = -0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V1 (4/21):\n", + " Subset 0: () gives pval = 0.07702 / val = 0.923\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V1 (5/21):\n", + " Subset 0: () gives pval = 0.96797 / val = -0.032\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V1 (6/21):\n", + " Subset 0: () gives pval = 0.09642 / val = -0.904\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V1 (7/21):\n", + " Subset 0: () gives pval = 0.44848 / val = -0.552\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V1 (8/21):\n", + " Subset 0: () gives pval = 0.68330 / val = 0.317\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V1 (9/21):\n", + " Subset 0: () gives pval = 0.54066 / val = 0.459\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V1 (10/21):\n", + " Subset 0: () gives pval = 0.29779 / val = -0.702\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V1 (11/21):\n", + " Subset 0: () gives pval = 0.52864 / val = -0.471\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V1 (12/21):\n", + " Subset 0: () gives pval = 0.20579 / val = 0.794\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V1 (13/21):\n", + " Subset 0: () gives pval = 0.39236 / val = 0.608\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V1 (14/21):\n", + " Subset 0: () gives pval = 0.67772 / val = -0.322\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V1 (15/21):\n", + " Subset 0: () gives pval = 0.21445 / val = 0.786\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V1 (16/21):\n", + " Subset 0: () gives pval = 0.07663 / val = -0.923\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V1 (17/21):\n", + " Subset 0: () gives pval = 0.90942 / val = -0.091\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V1 (18/21):\n", + " Subset 0: () gives pval = 0.24793 / val = 0.752\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V1 (19/21):\n", + " Subset 0: () gives pval = 0.95866 / val = 0.041\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V1 (20/21):\n", + " Subset 0: () gives pval = 0.02837 / val = -0.972\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V1 (21/21):\n", + " Subset 0: () gives pval = 0.95338 / val = 0.047\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V1\n", + "\n", + "## Variable V2\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V2 (1/21):\n", + " Subset 0: () gives pval = 0.10887 / val = -0.891\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V2 (2/21):\n", + " Subset 0: () gives pval = 0.95900 / val = -0.041\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V2 (3/21):\n", + " Subset 0: () gives pval = 0.35587 / val = 0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V2 (4/21):\n", + " Subset 0: () gives pval = 0.84212 / val = -0.158\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V2 (5/21):\n", + " Subset 0: () gives pval = 0.02381 / val = -0.976\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V2 (6/21):\n", + " Subset 0: () gives pval = 0.49923 / val = 0.501\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V2 (7/21):\n", + " Subset 0: () gives pval = 0.83019 / val = -0.170\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V2 (8/21):\n", + " Subset 0: () gives pval = 0.14931 / val = 0.851\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V2 (9/21):\n", + " Subset 0: () gives pval = 0.93518 / val = -0.065\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V2 (10/21):\n", + " Subset 0: () gives pval = 0.57191 / val = -0.428\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V2 (11/21):\n", + " Subset 0: () gives pval = 0.05965 / val = 0.940\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V2 (12/21):\n", + " Subset 0: () gives pval = 0.67197 / val = 0.328\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V2 (13/21):\n", + " Subset 0: () gives pval = 0.31401 / val = -0.686\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V2 (14/21):\n", + " Subset 0: () gives pval = 0.38770 / val = 0.612\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V2 (15/21):\n", + " Subset 0: () gives pval = 0.57992 / val = 0.420\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V2 (16/21):\n", + " Subset 0: () gives pval = 0.95332 / val = -0.047\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V2 (17/21):\n", + " Subset 0: () gives pval = 0.00295 / val = 0.997\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V2 (18/21):\n", + " Subset 0: () gives pval = 0.89811 / val = 0.102\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V2 (19/21):\n", + " Subset 0: () gives pval = 0.29986 / val = -0.700\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V2 (20/21):\n", + " Subset 0: () gives pval = 0.92687 / val = 0.073\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V2 (21/21):\n", + " Subset 0: () gives pval = 0.02116 / val = 0.979\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V2\n", + "\n", + "## Variable V3\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V3 (1/21):\n", + " Subset 0: () gives pval = 0.75382 / val = -0.246\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V3 (2/21):\n", + " Subset 0: () gives pval = 0.84711 / val = 0.153\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V3 (3/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V3 (4/21):\n", + " Subset 0: () gives pval = 0.48971 / val = 0.510\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V3 (5/21):\n", + " Subset 0: () gives pval = 0.86516 / val = 0.135\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V3 (6/21):\n", + " Subset 0: () gives pval = 0.37746 / val = -0.623\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V3 (7/21):\n", + " Subset 0: () gives pval = 0.11338 / val = -0.887\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V3 (8/21):\n", + " Subset 0: () gives pval = 0.67814 / val = 0.322\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V3 (9/21):\n", + " Subset 0: () gives pval = 0.83884 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V3 (10/21):\n", + " Subset 0: () gives pval = 0.76348 / val = -0.237\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V3 (11/21):\n", + " Subset 0: () gives pval = 0.59220 / val = -0.408\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V3 (12/21):\n", + " Subset 0: () gives pval = 0.64658 / val = 0.353\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V3 (13/21):\n", + " Subset 0: () gives pval = 0.14720 / val = 0.853\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V3 (14/21):\n", + " Subset 0: () gives pval = 0.23881 / val = -0.761\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V3 (15/21):\n", + " Subset 0: () gives pval = 0.59382 / val = 0.406\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V3 (16/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V3 (17/21):\n", + " Subset 0: () gives pval = 0.80931 / val = -0.191\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V3 (18/21):\n", + " Subset 0: () gives pval = 0.78890 / val = 0.211\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V3 (19/21):\n", + " Subset 0: () gives pval = 0.47777 / val = 0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V3 (20/21):\n", + " Subset 0: () gives pval = 0.36364 / val = -0.636\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V3 (21/21):\n", + " Subset 0: () gives pval = 0.96075 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V3\n", + "\n", + "## Variable V4\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V4 (1/21):\n", + " Subset 0: () gives pval = 0.45446 / val = 0.546\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V4 (2/21):\n", + " Subset 0: () gives pval = 0.63860 / val = 0.361\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V4 (3/21):\n", + " Subset 0: () gives pval = 0.44451 / val = -0.555\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V4 (4/21):\n", + " Subset 0: () gives pval = 0.86082 / val = 0.139\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V4 (5/21):\n", + " Subset 0: () gives pval = 0.16334 / val = 0.837\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V4 (6/21):\n", + " Subset 0: () gives pval = 0.50949 / val = -0.491\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V4 (7/21):\n", + " Subset 0: () gives pval = 0.62576 / val = -0.374\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V4 (8/21):\n", + " Subset 0: () gives pval = 0.51092 / val = -0.489\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V4 (9/21):\n", + " Subset 0: () gives pval = 0.71429 / val = -0.286\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V4 (10/21):\n", + " Subset 0: () gives pval = 0.58069 / val = 0.419\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V4 (11/21):\n", + " Subset 0: () gives pval = 0.18066 / val = -0.819\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V4 (12/21):\n", + " Subset 0: () gives pval = 0.71082 / val = -0.289\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V4 (13/21):\n", + " Subset 0: () gives pval = 0.05509 / val = 0.945\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V4 (14/21):\n", + " Subset 0: () gives pval = 0.06126 / val = -0.939\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V4 (15/21):\n", + " Subset 0: () gives pval = 0.69139 / val = -0.309\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V4 (16/21):\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V4 (17/21):\n", + " Subset 0: () gives pval = 0.15485 / val = -0.845\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V4 (18/21):\n", + " Subset 0: () gives pval = 0.77546 / val = -0.225\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V4 (19/21):\n", + " Subset 0: () gives pval = 0.07418 / val = 0.926\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V4 (20/21):\n", + " Subset 0: () gives pval = 0.83884 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V4 (21/21):\n", + " Subset 0: () gives pval = 0.23452 / val = -0.765\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V4\n", + "\n", + "## Variable V5\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V5 (1/21):\n", + " Subset 0: () gives pval = 0.40591 / val = -0.594\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V5 (2/21):\n", + " Subset 0: () gives pval = 0.22108 / val = 0.779\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V5 (3/21):\n", + " Subset 0: () gives pval = 0.18784 / val = 0.812\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V5 (4/21):\n", + " Subset 0: () gives pval = 0.33692 / val = -0.663\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V5 (5/21):\n", + " Subset 0: () gives pval = 0.56614 / val = -0.434\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V5 (6/21):\n", + " Subset 0: () gives pval = 0.27666 / val = 0.723\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V5 (7/21):\n", + " Subset 0: () gives pval = 0.49057 / val = -0.509\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V5 (8/21):\n", + " Subset 0: () gives pval = 0.44520 / val = 0.555\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V5 (9/21):\n", + " Subset 0: () gives pval = 0.15734 / val = -0.843\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V5 (10/21):\n", + " Subset 0: () gives pval = 0.66704 / val = 0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V5 (11/21):\n", + " Subset 0: () gives pval = 0.27833 / val = 0.722\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V5 (12/21):\n", + " Subset 0: () gives pval = 0.62823 / val = -0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V5 (13/21):\n", + " Subset 0: () gives pval = 0.82850 / val = -0.171\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V5 (14/21):\n", + " Subset 0: () gives pval = 0.86689 / val = -0.133\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V5 (15/21):\n", + " Subset 0: () gives pval = 0.76662 / val = -0.233\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V5 (16/21):\n", + " Subset 0: () gives pval = 0.48656 / val = 0.513\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V5 (17/21):\n", + " Subset 0: () gives pval = 0.46312 / val = 0.537\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V5 (18/21):\n", + " Subset 0: () gives pval = 0.35473 / val = -0.645\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V5 (19/21):\n", + " Subset 0: () gives pval = 0.85997 / val = 0.140\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V5 (20/21):\n", + " Subset 0: () gives pval = 0.48811 / val = 0.512\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V5 (21/21):\n", + " Subset 0: () gives pval = 0.46322 / val = 0.537\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V5\n", + "\n", + "## Variable V6\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V6 (1/21):\n", + " Subset 0: () gives pval = 0.72783 / val = 0.272\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V6 (2/21):\n", + " Subset 0: () gives pval = 0.15485 / val = 0.845\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V6 (3/21):\n", + " Subset 0: () gives pval = 0.96151 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V6 (4/21):\n", + " Subset 0: () gives pval = 0.60943 / val = -0.391\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V6 (5/21):\n", + " Subset 0: () gives pval = 0.40372 / val = 0.596\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V6 (6/21):\n", + " Subset 0: () gives pval = 0.92353 / val = 0.076\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V6 (7/21):\n", + " Subset 0: () gives pval = 0.48656 / val = -0.513\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V6 (8/21):\n", + " Subset 0: () gives pval = 0.74584 / val = -0.254\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V6 (9/21):\n", + " Subset 0: () gives pval = 0.19822 / val = -0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V6 (10/21):\n", + " Subset 0: () gives pval = 0.28091 / val = 0.719\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V6 (11/21):\n", + " Subset 0: () gives pval = 0.66939 / val = -0.331\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V6 (12/21):\n", + " Subset 0: () gives pval = 0.36883 / val = -0.631\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V6 (13/21):\n", + " Subset 0: () gives pval = 0.29289 / val = 0.707\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V6 (14/21):\n", + " Subset 0: () gives pval = 0.08530 / val = -0.915\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V6 (15/21):\n", + " Subset 0: () gives pval = 0.42265 / val = -0.577\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V6 (16/21):\n", + " Subset 0: () gives pval = 0.55095 / val = 0.449\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V6 (17/21):\n", + " Subset 0: () gives pval = 0.47295 / val = -0.527\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V6 (18/21):\n", + " Subset 0: () gives pval = 0.29986 / val = -0.700\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V6 (19/21):\n", + " Subset 0: () gives pval = 0.03775 / val = 0.962\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V6 (20/21):\n", + " Subset 0: () gives pval = 0.69849 / val = 0.302\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V6 (21/21):\n", + " Subset 0: () gives pval = 0.52264 / val = -0.477\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V6\n", + "\n", + "## Variable V7\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V7 (1/21):\n", + " Subset 0: () gives pval = 0.52860 / val = 0.471\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V7 (2/21):\n", + " Subset 0: () gives pval = 0.12169 / val = -0.878\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V7 (3/21):\n", + " Subset 0: () gives pval = 0.26667 / val = -0.733\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V7 (4/21):\n", + " Subset 0: () gives pval = 0.32352 / val = 0.676\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V7 (5/21):\n", + " Subset 0: () gives pval = 0.74180 / val = 0.258\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V7 (6/21):\n", + " Subset 0: () gives pval = 0.33773 / val = -0.662\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V7 (7/21):\n", + " Subset 0: () gives pval = 0.43408 / val = 0.566\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V7 (8/21):\n", + " Subset 0: () gives pval = 0.55977 / val = -0.440\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V7 (9/21):\n", + " Subset 0: () gives pval = 0.07418 / val = 0.926\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V7 (10/21):\n", + " Subset 0: () gives pval = 0.54709 / val = -0.453\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V7 (11/21):\n", + " Subset 0: () gives pval = 0.42736 / val = -0.573\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V7 (12/21):\n", + " Subset 0: () gives pval = 0.53148 / val = 0.469\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V7 (13/21):\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V7 (14/21):\n", + " Subset 0: () gives pval = 0.68314 / val = 0.317\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V7 (15/21):\n", + " Subset 0: () gives pval = 0.66667 / val = 0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V7 (16/21):\n", + " Subset 0: () gives pval = 0.44444 / val = -0.556\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V7 (17/21):\n", + " Subset 0: () gives pval = 0.63485 / val = -0.365\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V7 (18/21):\n", + " Subset 0: () gives pval = 0.27239 / val = 0.728\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V7 (19/21):\n", + " Subset 0: () gives pval = 0.66667 / val = -0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V7 (20/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V7 (21/21):\n", + " Subset 0: () gives pval = 0.62418 / val = -0.376\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V7\n", + "\n", + "## Resulting lagged parent (super)sets:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "##\n", + "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", + "##\n", + "\n", + "Parameters:\n", + "\n", + "independence test = par_corr\n", + "tau_min = 0\n", + "tau_max = 3\n", + "pc_alpha = 0.001\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "reset_lagged_links = False\n", + "max_conds_dim = None\n", + "max_conds_py = None\n", + "max_conds_px = None\n", + "max_conds_px_lagged = None\n", + "fdr_method = none\n", + "\n", + "--------------------------\n", + "Skeleton discovery phase\n", + "--------------------------\n", + "\n", + "Testing contemporaneous condition sets of dimension 0: \n", + "\n", + " Link (V1 0) o?o V2 (1/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.84368 / val = -0.156\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V3 (2/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.20111 / val = 0.799\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V4 (3/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.65550 / val = 0.345\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V5 (4/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.60053 / val = -0.399\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V6 (5/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.92839 / val = -0.072\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V7 (6/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.62790 / val = 0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V1 (7/42):\n", + " Already removed.\n", + "\n", + " Link (V2 0) o?o V3 (8/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.78062 / val = -0.219\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V4 (9/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.15734 / val = -0.843\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V5 (10/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.41176 / val = 0.588\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V6 (11/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.51493 / val = -0.485\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V7 (12/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.57992 / val = -0.420\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V1 (13/42):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V2 (14/42):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V4 (15/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.35534 / val = 0.645\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V5 (16/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.92687 / val = 0.073\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V6 (17/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.49748 / val = 0.503\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V7 (18/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.82592 / val = -0.174\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V1 (19/42):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V2 (20/42):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V3 (21/42):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V5 (22/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.80554 / val = -0.194\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V6 (23/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.19822 / val = 0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V7 (24/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V1 (25/42):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V2 (26/42):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V3 (27/42):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V4 (28/42):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V6 (29/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.59577 / val = 0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V7 (30/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.01980 / val = -0.980\n", + " Non-significance detected.\n", + "\n", + " Link (V6 0) o?o V1 (31/42):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V2 (32/42):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V3 (33/42):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V4 (34/42):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V5 (35/42):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V7 (36/42):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.42265 / val = -0.577\n", + " Non-significance detected.\n", + "\n", + " Link (V7 0) o?o V1 (37/42):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V2 (38/42):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V3 (39/42):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V4 (40/42):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V5 (41/42):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V6 (42/42):\n", + " Already removed.\n", + "\n", + "Updated contemp. adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged at p = 0.\n", + "\n", + "----------------------------\n", + "Collider orientation phase\n", + "----------------------------\n", + "\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "\n", + "----------------------------\n", + "Rule orientation phase\n", + "----------------------------\n", + "\n", + "Try rule(s) [1 2 3]\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## Significant links at alpha = 0.001:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## pc_alpha = 0.005 (2/5):\n", + "\n", + "##\n", + "## Step 1: PC1 algorithm for selecting lagged conditions\n", + "##\n", + "\n", + "Parameters:\n", + "independence test = par_corr\n", + "tau_min = 1\n", + "tau_max = 3\n", + "pc_alpha = [0.005]\n", + "max_conds_dim = None\n", + "max_combinations = 1\n", + "\n", + "\n", + "\n", + "## Variable V1\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V1 (1/21):\n", + " Subset 0: () gives pval = 0.76612 / val = -0.234\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V1 (2/21):\n", + " Subset 0: () gives pval = 0.52792 / val = -0.472\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V1 (3/21):\n", + " Subset 0: () gives pval = 0.19791 / val = -0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V1 (4/21):\n", + " Subset 0: () gives pval = 0.07702 / val = 0.923\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V1 (5/21):\n", + " Subset 0: () gives pval = 0.96797 / val = -0.032\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V1 (6/21):\n", + " Subset 0: () gives pval = 0.09642 / val = -0.904\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V1 (7/21):\n", + " Subset 0: () gives pval = 0.44848 / val = -0.552\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V1 (8/21):\n", + " Subset 0: () gives pval = 0.68330 / val = 0.317\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V1 (9/21):\n", + " Subset 0: () gives pval = 0.54066 / val = 0.459\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V1 (10/21):\n", + " Subset 0: () gives pval = 0.29779 / val = -0.702\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V1 (11/21):\n", + " Subset 0: () gives pval = 0.52864 / val = -0.471\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V1 (12/21):\n", + " Subset 0: () gives pval = 0.20579 / val = 0.794\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V1 (13/21):\n", + " Subset 0: () gives pval = 0.39236 / val = 0.608\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V1 (14/21):\n", + " Subset 0: () gives pval = 0.67772 / val = -0.322\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V1 (15/21):\n", + " Subset 0: () gives pval = 0.21445 / val = 0.786\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V1 (16/21):\n", + " Subset 0: () gives pval = 0.07663 / val = -0.923\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V1 (17/21):\n", + " Subset 0: () gives pval = 0.90942 / val = -0.091\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V1 (18/21):\n", + " Subset 0: () gives pval = 0.24793 / val = 0.752\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V1 (19/21):\n", + " Subset 0: () gives pval = 0.95866 / val = 0.041\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V1 (20/21):\n", + " Subset 0: () gives pval = 0.02837 / val = -0.972\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V1 (21/21):\n", + " Subset 0: () gives pval = 0.95338 / val = 0.047\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V1\n", + "\n", + "## Variable V2\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V2 (1/21):\n", + " Subset 0: () gives pval = 0.10887 / val = -0.891\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V2 (2/21):\n", + " Subset 0: () gives pval = 0.95900 / val = -0.041\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V2 (3/21):\n", + " Subset 0: () gives pval = 0.35587 / val = 0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V2 (4/21):\n", + " Subset 0: () gives pval = 0.84212 / val = -0.158\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V2 (5/21):\n", + " Subset 0: () gives pval = 0.02381 / val = -0.976\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V2 (6/21):\n", + " Subset 0: () gives pval = 0.49923 / val = 0.501\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V2 (7/21):\n", + " Subset 0: () gives pval = 0.83019 / val = -0.170\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V2 (8/21):\n", + " Subset 0: () gives pval = 0.14931 / val = 0.851\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V2 (9/21):\n", + " Subset 0: () gives pval = 0.93518 / val = -0.065\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V2 (10/21):\n", + " Subset 0: () gives pval = 0.57191 / val = -0.428\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V2 (11/21):\n", + " Subset 0: () gives pval = 0.05965 / val = 0.940\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V2 (12/21):\n", + " Subset 0: () gives pval = 0.67197 / val = 0.328\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V2 (13/21):\n", + " Subset 0: () gives pval = 0.31401 / val = -0.686\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V2 (14/21):\n", + " Subset 0: () gives pval = 0.38770 / val = 0.612\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V2 (15/21):\n", + " Subset 0: () gives pval = 0.57992 / val = 0.420\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V2 (16/21):\n", + " Subset 0: () gives pval = 0.95332 / val = -0.047\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V2 (17/21):\n", + " Subset 0: () gives pval = 0.00295 / val = 0.997\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V6 -3) -?> V2 (18/21):\n", + " Subset 0: () gives pval = 0.89811 / val = 0.102\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V2 (19/21):\n", + " Subset 0: () gives pval = 0.29986 / val = -0.700\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V2 (20/21):\n", + " Subset 0: () gives pval = 0.92687 / val = 0.073\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V2 (21/21):\n", + " Subset 0: () gives pval = 0.02116 / val = 0.979\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V6 -2): max_pval = 0.00295, |min_val| = 0.997\n", + "\n", + "Algorithm converged for variable V2\n", + "\n", + "## Variable V3\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V3 (1/21):\n", + " Subset 0: () gives pval = 0.75382 / val = -0.246\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V3 (2/21):\n", + " Subset 0: () gives pval = 0.84711 / val = 0.153\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V3 (3/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V3 (4/21):\n", + " Subset 0: () gives pval = 0.48971 / val = 0.510\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V3 (5/21):\n", + " Subset 0: () gives pval = 0.86516 / val = 0.135\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V3 (6/21):\n", + " Subset 0: () gives pval = 0.37746 / val = -0.623\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V3 (7/21):\n", + " Subset 0: () gives pval = 0.11338 / val = -0.887\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V3 (8/21):\n", + " Subset 0: () gives pval = 0.67814 / val = 0.322\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V3 (9/21):\n", + " Subset 0: () gives pval = 0.83884 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V3 (10/21):\n", + " Subset 0: () gives pval = 0.76348 / val = -0.237\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V3 (11/21):\n", + " Subset 0: () gives pval = 0.59220 / val = -0.408\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V3 (12/21):\n", + " Subset 0: () gives pval = 0.64658 / val = 0.353\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V3 (13/21):\n", + " Subset 0: () gives pval = 0.14720 / val = 0.853\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V3 (14/21):\n", + " Subset 0: () gives pval = 0.23881 / val = -0.761\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V3 (15/21):\n", + " Subset 0: () gives pval = 0.59382 / val = 0.406\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V3 (16/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V3 (17/21):\n", + " Subset 0: () gives pval = 0.80931 / val = -0.191\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V3 (18/21):\n", + " Subset 0: () gives pval = 0.78890 / val = 0.211\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V3 (19/21):\n", + " Subset 0: () gives pval = 0.47777 / val = 0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V3 (20/21):\n", + " Subset 0: () gives pval = 0.36364 / val = -0.636\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V3 (21/21):\n", + " Subset 0: () gives pval = 0.96075 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V3\n", + "\n", + "## Variable V4\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V4 (1/21):\n", + " Subset 0: () gives pval = 0.45446 / val = 0.546\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V4 (2/21):\n", + " Subset 0: () gives pval = 0.63860 / val = 0.361\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V4 (3/21):\n", + " Subset 0: () gives pval = 0.44451 / val = -0.555\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V4 (4/21):\n", + " Subset 0: () gives pval = 0.86082 / val = 0.139\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V4 (5/21):\n", + " Subset 0: () gives pval = 0.16334 / val = 0.837\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V4 (6/21):\n", + " Subset 0: () gives pval = 0.50949 / val = -0.491\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V4 (7/21):\n", + " Subset 0: () gives pval = 0.62576 / val = -0.374\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V4 (8/21):\n", + " Subset 0: () gives pval = 0.51092 / val = -0.489\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V4 (9/21):\n", + " Subset 0: () gives pval = 0.71429 / val = -0.286\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V4 (10/21):\n", + " Subset 0: () gives pval = 0.58069 / val = 0.419\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V4 (11/21):\n", + " Subset 0: () gives pval = 0.18066 / val = -0.819\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V4 (12/21):\n", + " Subset 0: () gives pval = 0.71082 / val = -0.289\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V4 (13/21):\n", + " Subset 0: () gives pval = 0.05509 / val = 0.945\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V4 (14/21):\n", + " Subset 0: () gives pval = 0.06126 / val = -0.939\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V4 (15/21):\n", + " Subset 0: () gives pval = 0.69139 / val = -0.309\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V4 (16/21):\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V4 (17/21):\n", + " Subset 0: () gives pval = 0.15485 / val = -0.845\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V4 (18/21):\n", + " Subset 0: () gives pval = 0.77546 / val = -0.225\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V4 (19/21):\n", + " Subset 0: () gives pval = 0.07418 / val = 0.926\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V4 (20/21):\n", + " Subset 0: () gives pval = 0.83884 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V4 (21/21):\n", + " Subset 0: () gives pval = 0.23452 / val = -0.765\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V4\n", + "\n", + "## Variable V5\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V5 (1/21):\n", + " Subset 0: () gives pval = 0.40591 / val = -0.594\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V5 (2/21):\n", + " Subset 0: () gives pval = 0.22108 / val = 0.779\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V5 (3/21):\n", + " Subset 0: () gives pval = 0.18784 / val = 0.812\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V5 (4/21):\n", + " Subset 0: () gives pval = 0.33692 / val = -0.663\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V5 (5/21):\n", + " Subset 0: () gives pval = 0.56614 / val = -0.434\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V5 (6/21):\n", + " Subset 0: () gives pval = 0.27666 / val = 0.723\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V5 (7/21):\n", + " Subset 0: () gives pval = 0.49057 / val = -0.509\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V5 (8/21):\n", + " Subset 0: () gives pval = 0.44520 / val = 0.555\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V5 (9/21):\n", + " Subset 0: () gives pval = 0.15734 / val = -0.843\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V5 (10/21):\n", + " Subset 0: () gives pval = 0.66704 / val = 0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V5 (11/21):\n", + " Subset 0: () gives pval = 0.27833 / val = 0.722\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V5 (12/21):\n", + " Subset 0: () gives pval = 0.62823 / val = -0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V5 (13/21):\n", + " Subset 0: () gives pval = 0.82850 / val = -0.171\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V5 (14/21):\n", + " Subset 0: () gives pval = 0.86689 / val = -0.133\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V5 (15/21):\n", + " Subset 0: () gives pval = 0.76662 / val = -0.233\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V5 (16/21):\n", + " Subset 0: () gives pval = 0.48656 / val = 0.513\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V5 (17/21):\n", + " Subset 0: () gives pval = 0.46312 / val = 0.537\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V5 (18/21):\n", + " Subset 0: () gives pval = 0.35473 / val = -0.645\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V5 (19/21):\n", + " Subset 0: () gives pval = 0.85997 / val = 0.140\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V5 (20/21):\n", + " Subset 0: () gives pval = 0.48811 / val = 0.512\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V5 (21/21):\n", + " Subset 0: () gives pval = 0.46322 / val = 0.537\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V5\n", + "\n", + "## Variable V6\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V6 (1/21):\n", + " Subset 0: () gives pval = 0.72783 / val = 0.272\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V6 (2/21):\n", + " Subset 0: () gives pval = 0.15485 / val = 0.845\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V6 (3/21):\n", + " Subset 0: () gives pval = 0.96151 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V6 (4/21):\n", + " Subset 0: () gives pval = 0.60943 / val = -0.391\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V6 (5/21):\n", + " Subset 0: () gives pval = 0.40372 / val = 0.596\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V6 (6/21):\n", + " Subset 0: () gives pval = 0.92353 / val = 0.076\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V6 (7/21):\n", + " Subset 0: () gives pval = 0.48656 / val = -0.513\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V6 (8/21):\n", + " Subset 0: () gives pval = 0.74584 / val = -0.254\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V6 (9/21):\n", + " Subset 0: () gives pval = 0.19822 / val = -0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V6 (10/21):\n", + " Subset 0: () gives pval = 0.28091 / val = 0.719\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V6 (11/21):\n", + " Subset 0: () gives pval = 0.66939 / val = -0.331\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V6 (12/21):\n", + " Subset 0: () gives pval = 0.36883 / val = -0.631\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V6 (13/21):\n", + " Subset 0: () gives pval = 0.29289 / val = 0.707\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V6 (14/21):\n", + " Subset 0: () gives pval = 0.08530 / val = -0.915\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V6 (15/21):\n", + " Subset 0: () gives pval = 0.42265 / val = -0.577\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V6 (16/21):\n", + " Subset 0: () gives pval = 0.55095 / val = 0.449\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V6 (17/21):\n", + " Subset 0: () gives pval = 0.47295 / val = -0.527\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V6 (18/21):\n", + " Subset 0: () gives pval = 0.29986 / val = -0.700\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V6 (19/21):\n", + " Subset 0: () gives pval = 0.03775 / val = 0.962\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V6 (20/21):\n", + " Subset 0: () gives pval = 0.69849 / val = 0.302\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V6 (21/21):\n", + " Subset 0: () gives pval = 0.52264 / val = -0.477\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V6\n", + "\n", + "## Variable V7\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V7 (1/21):\n", + " Subset 0: () gives pval = 0.52860 / val = 0.471\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V7 (2/21):\n", + " Subset 0: () gives pval = 0.12169 / val = -0.878\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V7 (3/21):\n", + " Subset 0: () gives pval = 0.26667 / val = -0.733\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V7 (4/21):\n", + " Subset 0: () gives pval = 0.32352 / val = 0.676\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V7 (5/21):\n", + " Subset 0: () gives pval = 0.74180 / val = 0.258\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V7 (6/21):\n", + " Subset 0: () gives pval = 0.33773 / val = -0.662\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V7 (7/21):\n", + " Subset 0: () gives pval = 0.43408 / val = 0.566\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V7 (8/21):\n", + " Subset 0: () gives pval = 0.55977 / val = -0.440\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V7 (9/21):\n", + " Subset 0: () gives pval = 0.07418 / val = 0.926\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V7 (10/21):\n", + " Subset 0: () gives pval = 0.54709 / val = -0.453\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V7 (11/21):\n", + " Subset 0: () gives pval = 0.42736 / val = -0.573\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V7 (12/21):\n", + " Subset 0: () gives pval = 0.53148 / val = 0.469\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V7 (13/21):\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V7 (14/21):\n", + " Subset 0: () gives pval = 0.68314 / val = 0.317\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V7 (15/21):\n", + " Subset 0: () gives pval = 0.66667 / val = 0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V7 (16/21):\n", + " Subset 0: () gives pval = 0.44444 / val = -0.556\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V7 (17/21):\n", + " Subset 0: () gives pval = 0.63485 / val = -0.365\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V7 (18/21):\n", + " Subset 0: () gives pval = 0.27239 / val = 0.728\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V7 (19/21):\n", + " Subset 0: () gives pval = 0.66667 / val = -0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V7 (20/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V7 (21/21):\n", + " Subset 0: () gives pval = 0.62418 / val = -0.376\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V7\n", + "\n", + "## Resulting lagged parent (super)sets:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V6 -2): max_pval = 0.00295, |min_val| = 0.997\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "##\n", + "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", + "##\n", + "\n", + "Parameters:\n", + "\n", + "independence test = par_corr\n", + "tau_min = 0\n", + "tau_max = 3\n", + "pc_alpha = 0.005\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "reset_lagged_links = False\n", + "max_conds_dim = None\n", + "max_conds_py = None\n", + "max_conds_px = None\n", + "max_conds_px_lagged = None\n", + "fdr_method = none\n", + "\n", + "--------------------------\n", + "Skeleton discovery phase\n", + "--------------------------\n", + "\n", + "Testing contemporaneous condition sets of dimension 0: \n", + "\n", + " Link (V1 0) o?o V2 (1/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V6 -2) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.33580 / val = -0.864\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V3 (2/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.20111 / val = 0.799\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V4 (3/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.65550 / val = 0.345\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V5 (4/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.60053 / val = -0.399\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V6 (5/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.92839 / val = -0.072\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V7 (6/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.62790 / val = 0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V1 (7/43):\n", + " Already removed.\n", + "\n", + " Link (V2 0) o?o V3 (8/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V6 -2) ]\n", + " Subset 0: () gives pval = 0.74598 / val = -0.389\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V4 (9/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V6 -2) ]\n", + " Subset 0: () gives pval = 1.00000 / val = -0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V5 (10/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V6 -2) ]\n", + " Subset 0: () gives pval = 0.38996 / val = 0.818\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V6 (11/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V6 -2) ]\n", + " Subset 0: () gives pval = 0.57412 / val = 0.620\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V7 (12/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V6 -2) ]\n", + " Subset 0: () gives pval = 0.42588 / val = -0.784\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V1 (13/43):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V2 (14/43):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V4 (15/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.35534 / val = 0.645\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V5 (16/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.92687 / val = 0.073\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V6 (17/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.49748 / val = 0.503\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V7 (18/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.82592 / val = -0.174\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V1 (19/43):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V2 (20/43):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V3 (21/43):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V5 (22/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.80554 / val = -0.194\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V6 (23/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.19822 / val = 0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V7 (24/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V1 (25/43):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V2 (26/43):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V3 (27/43):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V4 (28/43):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V6 (29/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.59577 / val = 0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V7 (30/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.01980 / val = -0.980\n", + " Non-significance detected.\n", + "\n", + " Link (V6 0) o?o V1 (31/43):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V2 (32/43):\n", + " Already removed.\n", + "\n", + " Link (V6 -2) -?> V2 (33/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.00295 / val = 0.997\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V6 0) o?o V3 (34/43):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V4 (35/43):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V5 (36/43):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V7 (37/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.42265 / val = -0.577\n", + " Non-significance detected.\n", + "\n", + " Link (V7 0) o?o V1 (38/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V2 (39/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V3 (40/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V4 (41/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V5 (42/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V6 (43/43):\n", + " Already removed.\n", + "\n", + "Updated contemp. adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged at p = 0.\n", + "\n", + "----------------------------\n", + "Collider orientation phase\n", + "----------------------------\n", + "\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V6 -2)\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "\n", + "----------------------------\n", + "Rule orientation phase\n", + "----------------------------\n", + "\n", + "Try rule(s) [1 2 3]\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V6 -2)\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## Significant links at alpha = 0.005:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V6 -2): pval = 0.00295 | val = 0.997\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## pc_alpha = 0.01 (3/5):\n", + "\n", + "##\n", + "## Step 1: PC1 algorithm for selecting lagged conditions\n", + "##\n", + "\n", + "Parameters:\n", + "independence test = par_corr\n", + "tau_min = 1\n", + "tau_max = 3\n", + "pc_alpha = [0.01]\n", + "max_conds_dim = None\n", + "max_combinations = 1\n", + "\n", + "\n", + "\n", + "## Variable V1\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V1 (1/21):\n", + " Subset 0: () gives pval = 0.76612 / val = -0.234\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V1 (2/21):\n", + " Subset 0: () gives pval = 0.52792 / val = -0.472\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V1 (3/21):\n", + " Subset 0: () gives pval = 0.19791 / val = -0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V1 (4/21):\n", + " Subset 0: () gives pval = 0.07702 / val = 0.923\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V1 (5/21):\n", + " Subset 0: () gives pval = 0.96797 / val = -0.032\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V1 (6/21):\n", + " Subset 0: () gives pval = 0.09642 / val = -0.904\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V1 (7/21):\n", + " Subset 0: () gives pval = 0.44848 / val = -0.552\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V1 (8/21):\n", + " Subset 0: () gives pval = 0.68330 / val = 0.317\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V1 (9/21):\n", + " Subset 0: () gives pval = 0.54066 / val = 0.459\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V1 (10/21):\n", + " Subset 0: () gives pval = 0.29779 / val = -0.702\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V1 (11/21):\n", + " Subset 0: () gives pval = 0.52864 / val = -0.471\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V1 (12/21):\n", + " Subset 0: () gives pval = 0.20579 / val = 0.794\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V1 (13/21):\n", + " Subset 0: () gives pval = 0.39236 / val = 0.608\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V1 (14/21):\n", + " Subset 0: () gives pval = 0.67772 / val = -0.322\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V1 (15/21):\n", + " Subset 0: () gives pval = 0.21445 / val = 0.786\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V1 (16/21):\n", + " Subset 0: () gives pval = 0.07663 / val = -0.923\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V1 (17/21):\n", + " Subset 0: () gives pval = 0.90942 / val = -0.091\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V1 (18/21):\n", + " Subset 0: () gives pval = 0.24793 / val = 0.752\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V1 (19/21):\n", + " Subset 0: () gives pval = 0.95866 / val = 0.041\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V1 (20/21):\n", + " Subset 0: () gives pval = 0.02837 / val = -0.972\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V1 (21/21):\n", + " Subset 0: () gives pval = 0.95338 / val = 0.047\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V1\n", + "\n", + "## Variable V2\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V2 (1/21):\n", + " Subset 0: () gives pval = 0.10887 / val = -0.891\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V2 (2/21):\n", + " Subset 0: () gives pval = 0.95900 / val = -0.041\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V2 (3/21):\n", + " Subset 0: () gives pval = 0.35587 / val = 0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V2 (4/21):\n", + " Subset 0: () gives pval = 0.84212 / val = -0.158\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V2 (5/21):\n", + " Subset 0: () gives pval = 0.02381 / val = -0.976\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V2 (6/21):\n", + " Subset 0: () gives pval = 0.49923 / val = 0.501\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V2 (7/21):\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Subset 0: () gives pval = 0.83019 / val = -0.170\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V2 (8/21):\n", + " Subset 0: () gives pval = 0.14931 / val = 0.851\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V2 (9/21):\n", + " Subset 0: () gives pval = 0.93518 / val = -0.065\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V2 (10/21):\n", + " Subset 0: () gives pval = 0.57191 / val = -0.428\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V2 (11/21):\n", + " Subset 0: () gives pval = 0.05965 / val = 0.940\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V2 (12/21):\n", + " Subset 0: () gives pval = 0.67197 / val = 0.328\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V2 (13/21):\n", + " Subset 0: () gives pval = 0.31401 / val = -0.686\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V2 (14/21):\n", + " Subset 0: () gives pval = 0.38770 / val = 0.612\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V2 (15/21):\n", + " Subset 0: () gives pval = 0.57992 / val = 0.420\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V2 (16/21):\n", + " Subset 0: () gives pval = 0.95332 / val = -0.047\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V2 (17/21):\n", + " Subset 0: () gives pval = 0.00295 / val = 0.997\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V6 -3) -?> V2 (18/21):\n", + " Subset 0: () gives pval = 0.89811 / val = 0.102\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V2 (19/21):\n", + " Subset 0: () gives pval = 0.29986 / val = -0.700\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V2 (20/21):\n", + " Subset 0: () gives pval = 0.92687 / val = 0.073\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V2 (21/21):\n", + " Subset 0: () gives pval = 0.02116 / val = 0.979\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V6 -2): max_pval = 0.00295, |min_val| = 0.997\n", + "\n", + "Algorithm converged for variable V2\n", + "\n", + "## Variable V3\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V3 (1/21):\n", + " Subset 0: () gives pval = 0.75382 / val = -0.246\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V3 (2/21):\n", + " Subset 0: () gives pval = 0.84711 / val = 0.153\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V3 (3/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V3 (4/21):\n", + " Subset 0: () gives pval = 0.48971 / val = 0.510\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V3 (5/21):\n", + " Subset 0: () gives pval = 0.86516 / val = 0.135\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V3 (6/21):\n", + " Subset 0: () gives pval = 0.37746 / val = -0.623\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V3 (7/21):\n", + " Subset 0: () gives pval = 0.11338 / val = -0.887\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V3 (8/21):\n", + " Subset 0: () gives pval = 0.67814 / val = 0.322\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V3 (9/21):\n", + " Subset 0: () gives pval = 0.83884 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V3 (10/21):\n", + " Subset 0: () gives pval = 0.76348 / val = -0.237\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V3 (11/21):\n", + " Subset 0: () gives pval = 0.59220 / val = -0.408\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V3 (12/21):\n", + " Subset 0: () gives pval = 0.64658 / val = 0.353\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V3 (13/21):\n", + " Subset 0: () gives pval = 0.14720 / val = 0.853\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V3 (14/21):\n", + " Subset 0: () gives pval = 0.23881 / val = -0.761\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V3 (15/21):\n", + " Subset 0: () gives pval = 0.59382 / val = 0.406\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V3 (16/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V3 (17/21):\n", + " Subset 0: () gives pval = 0.80931 / val = -0.191\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V3 (18/21):\n", + " Subset 0: () gives pval = 0.78890 / val = 0.211\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V3 (19/21):\n", + " Subset 0: () gives pval = 0.47777 / val = 0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V3 (20/21):\n", + " Subset 0: () gives pval = 0.36364 / val = -0.636\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V3 (21/21):\n", + " Subset 0: () gives pval = 0.96075 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V3\n", + "\n", + "## Variable V4\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V4 (1/21):\n", + " Subset 0: () gives pval = 0.45446 / val = 0.546\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V4 (2/21):\n", + " Subset 0: () gives pval = 0.63860 / val = 0.361\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V4 (3/21):\n", + " Subset 0: () gives pval = 0.44451 / val = -0.555\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V4 (4/21):\n", + " Subset 0: () gives pval = 0.86082 / val = 0.139\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V4 (5/21):\n", + " Subset 0: () gives pval = 0.16334 / val = 0.837\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V4 (6/21):\n", + " Subset 0: () gives pval = 0.50949 / val = -0.491\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V4 (7/21):\n", + " Subset 0: () gives pval = 0.62576 / val = -0.374\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V4 (8/21):\n", + " Subset 0: () gives pval = 0.51092 / val = -0.489\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V4 (9/21):\n", + " Subset 0: () gives pval = 0.71429 / val = -0.286\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V4 (10/21):\n", + " Subset 0: () gives pval = 0.58069 / val = 0.419\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V4 (11/21):\n", + " Subset 0: () gives pval = 0.18066 / val = -0.819\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V4 (12/21):\n", + " Subset 0: () gives pval = 0.71082 / val = -0.289\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V4 (13/21):\n", + " Subset 0: () gives pval = 0.05509 / val = 0.945\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V4 (14/21):\n", + " Subset 0: () gives pval = 0.06126 / val = -0.939\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V4 (15/21):\n", + " Subset 0: () gives pval = 0.69139 / val = -0.309\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V4 (16/21):\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V4 (17/21):\n", + " Subset 0: () gives pval = 0.15485 / val = -0.845\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V4 (18/21):\n", + " Subset 0: () gives pval = 0.77546 / val = -0.225\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V4 (19/21):\n", + " Subset 0: () gives pval = 0.07418 / val = 0.926\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V4 (20/21):\n", + " Subset 0: () gives pval = 0.83884 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V4 (21/21):\n", + " Subset 0: () gives pval = 0.23452 / val = -0.765\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V4\n", + "\n", + "## Variable V5\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V5 (1/21):\n", + " Subset 0: () gives pval = 0.40591 / val = -0.594\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V5 (2/21):\n", + " Subset 0: () gives pval = 0.22108 / val = 0.779\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V5 (3/21):\n", + " Subset 0: () gives pval = 0.18784 / val = 0.812\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V5 (4/21):\n", + " Subset 0: () gives pval = 0.33692 / val = -0.663\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V5 (5/21):\n", + " Subset 0: () gives pval = 0.56614 / val = -0.434\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V5 (6/21):\n", + " Subset 0: () gives pval = 0.27666 / val = 0.723\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V5 (7/21):\n", + " Subset 0: () gives pval = 0.49057 / val = -0.509\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V5 (8/21):\n", + " Subset 0: () gives pval = 0.44520 / val = 0.555\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V5 (9/21):\n", + " Subset 0: () gives pval = 0.15734 / val = -0.843\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V5 (10/21):\n", + " Subset 0: () gives pval = 0.66704 / val = 0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V5 (11/21):\n", + " Subset 0: () gives pval = 0.27833 / val = 0.722\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V5 (12/21):\n", + " Subset 0: () gives pval = 0.62823 / val = -0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V5 (13/21):\n", + " Subset 0: () gives pval = 0.82850 / val = -0.171\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V5 (14/21):\n", + " Subset 0: () gives pval = 0.86689 / val = -0.133\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V5 (15/21):\n", + " Subset 0: () gives pval = 0.76662 / val = -0.233\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V5 (16/21):\n", + " Subset 0: () gives pval = 0.48656 / val = 0.513\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V5 (17/21):\n", + " Subset 0: () gives pval = 0.46312 / val = 0.537\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V5 (18/21):\n", + " Subset 0: () gives pval = 0.35473 / val = -0.645\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V5 (19/21):\n", + " Subset 0: () gives pval = 0.85997 / val = 0.140\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V5 (20/21):\n", + " Subset 0: () gives pval = 0.48811 / val = 0.512\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V5 (21/21):\n", + " Subset 0: () gives pval = 0.46322 / val = 0.537\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V5\n", + "\n", + "## Variable V6\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V6 (1/21):\n", + " Subset 0: () gives pval = 0.72783 / val = 0.272\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V6 (2/21):\n", + " Subset 0: () gives pval = 0.15485 / val = 0.845\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V6 (3/21):\n", + " Subset 0: () gives pval = 0.96151 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V6 (4/21):\n", + " Subset 0: () gives pval = 0.60943 / val = -0.391\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V6 (5/21):\n", + " Subset 0: () gives pval = 0.40372 / val = 0.596\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V6 (6/21):\n", + " Subset 0: () gives pval = 0.92353 / val = 0.076\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V6 (7/21):\n", + " Subset 0: () gives pval = 0.48656 / val = -0.513\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V6 (8/21):\n", + " Subset 0: () gives pval = 0.74584 / val = -0.254\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V6 (9/21):\n", + " Subset 0: () gives pval = 0.19822 / val = -0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V6 (10/21):\n", + " Subset 0: () gives pval = 0.28091 / val = 0.719\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V6 (11/21):\n", + " Subset 0: () gives pval = 0.66939 / val = -0.331\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V6 (12/21):\n", + " Subset 0: () gives pval = 0.36883 / val = -0.631\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V6 (13/21):\n", + " Subset 0: () gives pval = 0.29289 / val = 0.707\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V6 (14/21):\n", + " Subset 0: () gives pval = 0.08530 / val = -0.915\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V6 (15/21):\n", + " Subset 0: () gives pval = 0.42265 / val = -0.577\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V6 (16/21):\n", + " Subset 0: () gives pval = 0.55095 / val = 0.449\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V6 (17/21):\n", + " Subset 0: () gives pval = 0.47295 / val = -0.527\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V6 (18/21):\n", + " Subset 0: () gives pval = 0.29986 / val = -0.700\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V6 (19/21):\n", + " Subset 0: () gives pval = 0.03775 / val = 0.962\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V6 (20/21):\n", + " Subset 0: () gives pval = 0.69849 / val = 0.302\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V6 (21/21):\n", + " Subset 0: () gives pval = 0.52264 / val = -0.477\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V6\n", + "\n", + "## Variable V7\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V7 (1/21):\n", + " Subset 0: () gives pval = 0.52860 / val = 0.471\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V7 (2/21):\n", + " Subset 0: () gives pval = 0.12169 / val = -0.878\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V7 (3/21):\n", + " Subset 0: () gives pval = 0.26667 / val = -0.733\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V7 (4/21):\n", + " Subset 0: () gives pval = 0.32352 / val = 0.676\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V7 (5/21):\n", + " Subset 0: () gives pval = 0.74180 / val = 0.258\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V7 (6/21):\n", + " Subset 0: () gives pval = 0.33773 / val = -0.662\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V7 (7/21):\n", + " Subset 0: () gives pval = 0.43408 / val = 0.566\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V7 (8/21):\n", + " Subset 0: () gives pval = 0.55977 / val = -0.440\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V7 (9/21):\n", + " Subset 0: () gives pval = 0.07418 / val = 0.926\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V7 (10/21):\n", + " Subset 0: () gives pval = 0.54709 / val = -0.453\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V7 (11/21):\n", + " Subset 0: () gives pval = 0.42736 / val = -0.573\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V7 (12/21):\n", + " Subset 0: () gives pval = 0.53148 / val = 0.469\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V7 (13/21):\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V7 (14/21):\n", + " Subset 0: () gives pval = 0.68314 / val = 0.317\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V7 (15/21):\n", + " Subset 0: () gives pval = 0.66667 / val = 0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V7 (16/21):\n", + " Subset 0: () gives pval = 0.44444 / val = -0.556\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V7 (17/21):\n", + " Subset 0: () gives pval = 0.63485 / val = -0.365\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V7 (18/21):\n", + " Subset 0: () gives pval = 0.27239 / val = 0.728\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V7 (19/21):\n", + " Subset 0: () gives pval = 0.66667 / val = -0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V7 (20/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V7 (21/21):\n", + " Subset 0: () gives pval = 0.62418 / val = -0.376\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V7\n", + "\n", + "## Resulting lagged parent (super)sets:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V6 -2): max_pval = 0.00295, |min_val| = 0.997\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "##\n", + "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", + "##\n", + "\n", + "Parameters:\n", + "\n", + "independence test = par_corr\n", + "tau_min = 0\n", + "tau_max = 3\n", + "pc_alpha = 0.01\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "reset_lagged_links = False\n", + "max_conds_dim = None\n", + "max_conds_py = None\n", + "max_conds_px = None\n", + "max_conds_px_lagged = None\n", + "fdr_method = none\n", + "\n", + "--------------------------\n", + "Skeleton discovery phase\n", + "--------------------------\n", + "\n", + "Testing contemporaneous condition sets of dimension 0: \n", + "\n", + " Link (V1 0) o?o V2 (1/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V6 -2) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.33580 / val = -0.864\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V3 (2/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.20111 / val = 0.799\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V4 (3/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.65550 / val = 0.345\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V5 (4/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.60053 / val = -0.399\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V6 (5/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.92839 / val = -0.072\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V7 (6/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.62790 / val = 0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V1 (7/43):\n", + " Already removed.\n", + "\n", + " Link (V2 0) o?o V3 (8/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V6 -2) ]\n", + " Subset 0: () gives pval = 0.74598 / val = -0.389\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V4 (9/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V6 -2) ]\n", + " Subset 0: () gives pval = 1.00000 / val = -0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V5 (10/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V6 -2) ]\n", + " Subset 0: () gives pval = 0.38996 / val = 0.818\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V6 (11/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V6 -2) ]\n", + " Subset 0: () gives pval = 0.57412 / val = 0.620\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V7 (12/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V6 -2) ]\n", + " Subset 0: () gives pval = 0.42588 / val = -0.784\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V1 (13/43):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V2 (14/43):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V4 (15/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.35534 / val = 0.645\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V5 (16/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.92687 / val = 0.073\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V6 (17/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.49748 / val = 0.503\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V7 (18/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.82592 / val = -0.174\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V1 (19/43):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V2 (20/43):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V3 (21/43):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V5 (22/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.80554 / val = -0.194\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V6 (23/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.19822 / val = 0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V7 (24/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V1 (25/43):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V2 (26/43):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V3 (27/43):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V4 (28/43):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V6 (29/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.59577 / val = 0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V7 (30/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.01980 / val = -0.980\n", + " Non-significance detected.\n", + "\n", + " Link (V6 0) o?o V1 (31/43):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V2 (32/43):\n", + " Already removed.\n", + "\n", + " Link (V6 -2) -?> V2 (33/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.00295 / val = 0.997\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V6 0) o?o V3 (34/43):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V4 (35/43):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V5 (36/43):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V7 (37/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.42265 / val = -0.577\n", + " Non-significance detected.\n", + "\n", + " Link (V7 0) o?o V1 (38/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V2 (39/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V3 (40/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V4 (41/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V5 (42/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V6 (43/43):\n", + " Already removed.\n", + "\n", + "Updated contemp. adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged at p = 0.\n", + "\n", + "----------------------------\n", + "Collider orientation phase\n", + "----------------------------\n", + "\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V6 -2)\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "\n", + "----------------------------\n", + "Rule orientation phase\n", + "----------------------------\n", + "\n", + "Try rule(s) [1 2 3]\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V6 -2)\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## Significant links at alpha = 0.01:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V6 -2): pval = 0.00295 | val = 0.997\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## pc_alpha = 0.025 (4/5):\n", + "\n", + "##\n", + "## Step 1: PC1 algorithm for selecting lagged conditions\n", + "##\n", + "\n", + "Parameters:\n", + "independence test = par_corr\n", + "tau_min = 1\n", + "tau_max = 3\n", + "pc_alpha = [0.025]\n", + "max_conds_dim = None\n", + "max_combinations = 1\n", + "\n", + "\n", + "\n", + "## Variable V1\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V1 (1/21):\n", + " Subset 0: () gives pval = 0.76612 / val = -0.234\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V1 (2/21):\n", + " Subset 0: () gives pval = 0.52792 / val = -0.472\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V1 (3/21):\n", + " Subset 0: () gives pval = 0.19791 / val = -0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V1 (4/21):\n", + " Subset 0: () gives pval = 0.07702 / val = 0.923\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V1 (5/21):\n", + " Subset 0: () gives pval = 0.96797 / val = -0.032\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V1 (6/21):\n", + " Subset 0: () gives pval = 0.09642 / val = -0.904\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V1 (7/21):\n", + " Subset 0: () gives pval = 0.44848 / val = -0.552\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V1 (8/21):\n", + " Subset 0: () gives pval = 0.68330 / val = 0.317\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V1 (9/21):\n", + " Subset 0: () gives pval = 0.54066 / val = 0.459\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V1 (10/21):\n", + " Subset 0: () gives pval = 0.29779 / val = -0.702\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V1 (11/21):\n", + " Subset 0: () gives pval = 0.52864 / val = -0.471\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V1 (12/21):\n", + " Subset 0: () gives pval = 0.20579 / val = 0.794\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V1 (13/21):\n", + " Subset 0: () gives pval = 0.39236 / val = 0.608\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V1 (14/21):\n", + " Subset 0: () gives pval = 0.67772 / val = -0.322\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V1 (15/21):\n", + " Subset 0: () gives pval = 0.21445 / val = 0.786\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V1 (16/21):\n", + " Subset 0: () gives pval = 0.07663 / val = -0.923\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V1 (17/21):\n", + " Subset 0: () gives pval = 0.90942 / val = -0.091\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V1 (18/21):\n", + " Subset 0: () gives pval = 0.24793 / val = 0.752\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V1 (19/21):\n", + " Subset 0: () gives pval = 0.95866 / val = 0.041\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V1 (20/21):\n", + " Subset 0: () gives pval = 0.02837 / val = -0.972\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V1 (21/21):\n", + " Subset 0: () gives pval = 0.95338 / val = 0.047\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V1\n", + "\n", + "## Variable V2\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V2 (1/21):\n", + " Subset 0: () gives pval = 0.10887 / val = -0.891\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V2 (2/21):\n", + " Subset 0: () gives pval = 0.95900 / val = -0.041\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V2 (3/21):\n", + " Subset 0: () gives pval = 0.35587 / val = 0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V2 (4/21):\n", + " Subset 0: () gives pval = 0.84212 / val = -0.158\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V2 (5/21):\n", + " Subset 0: () gives pval = 0.02381 / val = -0.976\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V2 -3) -?> V2 (6/21):\n", + " Subset 0: () gives pval = 0.49923 / val = 0.501\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V2 (7/21):\n", + " Subset 0: () gives pval = 0.83019 / val = -0.170\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V2 (8/21):\n", + " Subset 0: () gives pval = 0.14931 / val = 0.851\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V2 (9/21):\n", + " Subset 0: () gives pval = 0.93518 / val = -0.065\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V2 (10/21):\n", + " Subset 0: () gives pval = 0.57191 / val = -0.428\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V2 (11/21):\n", + " Subset 0: () gives pval = 0.05965 / val = 0.940\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V2 (12/21):\n", + " Subset 0: () gives pval = 0.67197 / val = 0.328\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V2 (13/21):\n", + " Subset 0: () gives pval = 0.31401 / val = -0.686\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V2 (14/21):\n", + " Subset 0: () gives pval = 0.38770 / val = 0.612\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V2 (15/21):\n", + " Subset 0: () gives pval = 0.57992 / val = 0.420\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V2 (16/21):\n", + " Subset 0: () gives pval = 0.95332 / val = -0.047\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V2 (17/21):\n", + " Subset 0: () gives pval = 0.00295 / val = 0.997\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V6 -3) -?> V2 (18/21):\n", + " Subset 0: () gives pval = 0.89811 / val = 0.102\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V2 (19/21):\n", + " Subset 0: () gives pval = 0.29986 / val = -0.700\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V2 (20/21):\n", + " Subset 0: () gives pval = 0.92687 / val = 0.073\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V2 (21/21):\n", + " Subset 0: () gives pval = 0.02116 / val = 0.979\n", + " No conditions of dimension 0 left.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V2 has 3 link(s):\n", + " (V6 -2): max_pval = 0.00295, |min_val| = 0.997\n", + " (V7 -3): max_pval = 0.02116, |min_val| = 0.979\n", + " (V2 -2): max_pval = 0.02381, |min_val| = 0.976\n", + "\n", + "Testing condition sets of dimension 1:\n", + "\n", + " Link (V6 -2) -?> V2 (1/3):\n", + " Subset 0: (V7 -3) gives pval = 0.20519 / val = 0.949\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V2 (2/3):\n", + " Subset 0: (V6 -2) gives pval = 0.64098 / val = -0.535\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V2 (3/3):\n", + " Subset 0: (V6 -2) gives pval = 0.00000 / val = 1.000\n", + " No conditions of dimension 1 left.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.02381, |min_val| = 0.976\n", + "\n", + "Algorithm converged for variable V2\n", + "\n", + "## Variable V3\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V3 (1/21):\n", + " Subset 0: () gives pval = 0.75382 / val = -0.246\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V3 (2/21):\n", + " Subset 0: () gives pval = 0.84711 / val = 0.153\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V3 (3/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V3 (4/21):\n", + " Subset 0: () gives pval = 0.48971 / val = 0.510\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V3 (5/21):\n", + " Subset 0: () gives pval = 0.86516 / val = 0.135\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V3 (6/21):\n", + " Subset 0: () gives pval = 0.37746 / val = -0.623\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V3 (7/21):\n", + " Subset 0: () gives pval = 0.11338 / val = -0.887\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V3 (8/21):\n", + " Subset 0: () gives pval = 0.67814 / val = 0.322\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V3 (9/21):\n", + " Subset 0: () gives pval = 0.83884 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V3 (10/21):\n", + " Subset 0: () gives pval = 0.76348 / val = -0.237\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V3 (11/21):\n", + " Subset 0: () gives pval = 0.59220 / val = -0.408\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V3 (12/21):\n", + " Subset 0: () gives pval = 0.64658 / val = 0.353\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V3 (13/21):\n", + " Subset 0: () gives pval = 0.14720 / val = 0.853\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V3 (14/21):\n", + " Subset 0: () gives pval = 0.23881 / val = -0.761\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V3 (15/21):\n", + " Subset 0: () gives pval = 0.59382 / val = 0.406\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V3 (16/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V3 (17/21):\n", + " Subset 0: () gives pval = 0.80931 / val = -0.191\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V3 (18/21):\n", + " Subset 0: () gives pval = 0.78890 / val = 0.211\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V3 (19/21):\n", + " Subset 0: () gives pval = 0.47777 / val = 0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V3 (20/21):\n", + " Subset 0: () gives pval = 0.36364 / val = -0.636\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V3 (21/21):\n", + " Subset 0: () gives pval = 0.96075 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V3\n", + "\n", + "## Variable V4\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V4 (1/21):\n", + " Subset 0: () gives pval = 0.45446 / val = 0.546\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V4 (2/21):\n", + " Subset 0: () gives pval = 0.63860 / val = 0.361\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V4 (3/21):\n", + " Subset 0: () gives pval = 0.44451 / val = -0.555\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V4 (4/21):\n", + " Subset 0: () gives pval = 0.86082 / val = 0.139\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V4 (5/21):\n", + " Subset 0: () gives pval = 0.16334 / val = 0.837\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V4 (6/21):\n", + " Subset 0: () gives pval = 0.50949 / val = -0.491\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V4 (7/21):\n", + " Subset 0: () gives pval = 0.62576 / val = -0.374\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V4 (8/21):\n", + " Subset 0: () gives pval = 0.51092 / val = -0.489\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V4 (9/21):\n", + " Subset 0: () gives pval = 0.71429 / val = -0.286\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V4 (10/21):\n", + " Subset 0: () gives pval = 0.58069 / val = 0.419\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V4 (11/21):\n", + " Subset 0: () gives pval = 0.18066 / val = -0.819\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V4 (12/21):\n", + " Subset 0: () gives pval = 0.71082 / val = -0.289\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V4 (13/21):\n", + " Subset 0: () gives pval = 0.05509 / val = 0.945\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V4 (14/21):\n", + " Subset 0: () gives pval = 0.06126 / val = -0.939\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V4 (15/21):\n", + " Subset 0: () gives pval = 0.69139 / val = -0.309\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V4 (16/21):\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V4 (17/21):\n", + " Subset 0: () gives pval = 0.15485 / val = -0.845\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V4 (18/21):\n", + " Subset 0: () gives pval = 0.77546 / val = -0.225\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V4 (19/21):\n", + " Subset 0: () gives pval = 0.07418 / val = 0.926\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V4 (20/21):\n", + " Subset 0: () gives pval = 0.83884 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V4 (21/21):\n", + " Subset 0: () gives pval = 0.23452 / val = -0.765\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V4\n", + "\n", + "## Variable V5\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V5 (1/21):\n", + " Subset 0: () gives pval = 0.40591 / val = -0.594\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V5 (2/21):\n", + " Subset 0: () gives pval = 0.22108 / val = 0.779\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V5 (3/21):\n", + " Subset 0: () gives pval = 0.18784 / val = 0.812\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V5 (4/21):\n", + " Subset 0: () gives pval = 0.33692 / val = -0.663\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V5 (5/21):\n", + " Subset 0: () gives pval = 0.56614 / val = -0.434\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V5 (6/21):\n", + " Subset 0: () gives pval = 0.27666 / val = 0.723\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V5 (7/21):\n", + " Subset 0: () gives pval = 0.49057 / val = -0.509\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V5 (8/21):\n", + " Subset 0: () gives pval = 0.44520 / val = 0.555\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V5 (9/21):\n", + " Subset 0: () gives pval = 0.15734 / val = -0.843\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V5 (10/21):\n", + " Subset 0: () gives pval = 0.66704 / val = 0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V5 (11/21):\n", + " Subset 0: () gives pval = 0.27833 / val = 0.722\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V5 (12/21):\n", + " Subset 0: () gives pval = 0.62823 / val = -0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V5 (13/21):\n", + " Subset 0: () gives pval = 0.82850 / val = -0.171\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V5 (14/21):\n", + " Subset 0: () gives pval = 0.86689 / val = -0.133\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V5 (15/21):\n", + " Subset 0: () gives pval = 0.76662 / val = -0.233\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V5 (16/21):\n", + " Subset 0: () gives pval = 0.48656 / val = 0.513\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V5 (17/21):\n", + " Subset 0: () gives pval = 0.46312 / val = 0.537\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V5 (18/21):\n", + " Subset 0: () gives pval = 0.35473 / val = -0.645\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V5 (19/21):\n", + " Subset 0: () gives pval = 0.85997 / val = 0.140\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V5 (20/21):\n", + " Subset 0: () gives pval = 0.48811 / val = 0.512\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V5 (21/21):\n", + " Subset 0: () gives pval = 0.46322 / val = 0.537\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V5\n", + "\n", + "## Variable V6\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V6 (1/21):\n", + " Subset 0: () gives pval = 0.72783 / val = 0.272\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V6 (2/21):\n", + " Subset 0: () gives pval = 0.15485 / val = 0.845\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V6 (3/21):\n", + " Subset 0: () gives pval = 0.96151 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V6 (4/21):\n", + " Subset 0: () gives pval = 0.60943 / val = -0.391\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V6 (5/21):\n", + " Subset 0: () gives pval = 0.40372 / val = 0.596\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V6 (6/21):\n", + " Subset 0: () gives pval = 0.92353 / val = 0.076\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V6 (7/21):\n", + " Subset 0: () gives pval = 0.48656 / val = -0.513\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V6 (8/21):\n", + " Subset 0: () gives pval = 0.74584 / val = -0.254\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V6 (9/21):\n", + " Subset 0: () gives pval = 0.19822 / val = -0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V6 (10/21):\n", + " Subset 0: () gives pval = 0.28091 / val = 0.719\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V6 (11/21):\n", + " Subset 0: () gives pval = 0.66939 / val = -0.331\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V6 (12/21):\n", + " Subset 0: () gives pval = 0.36883 / val = -0.631\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V6 (13/21):\n", + " Subset 0: () gives pval = 0.29289 / val = 0.707\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V6 (14/21):\n", + " Subset 0: () gives pval = 0.08530 / val = -0.915\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V6 (15/21):\n", + " Subset 0: () gives pval = 0.42265 / val = -0.577\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V6 (16/21):\n", + " Subset 0: () gives pval = 0.55095 / val = 0.449\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V6 (17/21):\n", + " Subset 0: () gives pval = 0.47295 / val = -0.527\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V6 (18/21):\n", + " Subset 0: () gives pval = 0.29986 / val = -0.700\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V6 (19/21):\n", + " Subset 0: () gives pval = 0.03775 / val = 0.962\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V6 (20/21):\n", + " Subset 0: () gives pval = 0.69849 / val = 0.302\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V6 (21/21):\n", + " Subset 0: () gives pval = 0.52264 / val = -0.477\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V6\n", + "\n", + "## Variable V7\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V7 (1/21):\n", + " Subset 0: () gives pval = 0.52860 / val = 0.471\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V7 (2/21):\n", + " Subset 0: () gives pval = 0.12169 / val = -0.878\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V7 (3/21):\n", + " Subset 0: () gives pval = 0.26667 / val = -0.733\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V7 (4/21):\n", + " Subset 0: () gives pval = 0.32352 / val = 0.676\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V7 (5/21):\n", + " Subset 0: () gives pval = 0.74180 / val = 0.258\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V7 (6/21):\n", + " Subset 0: () gives pval = 0.33773 / val = -0.662\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V7 (7/21):\n", + " Subset 0: () gives pval = 0.43408 / val = 0.566\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V7 (8/21):\n", + " Subset 0: () gives pval = 0.55977 / val = -0.440\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V7 (9/21):\n", + " Subset 0: () gives pval = 0.07418 / val = 0.926\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V7 (10/21):\n", + " Subset 0: () gives pval = 0.54709 / val = -0.453\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V7 (11/21):\n", + " Subset 0: () gives pval = 0.42736 / val = -0.573\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V7 (12/21):\n", + " Subset 0: () gives pval = 0.53148 / val = 0.469\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V7 (13/21):\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V7 (14/21):\n", + " Subset 0: () gives pval = 0.68314 / val = 0.317\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V7 (15/21):\n", + " Subset 0: () gives pval = 0.66667 / val = 0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V7 (16/21):\n", + " Subset 0: () gives pval = 0.44444 / val = -0.556\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V7 (17/21):\n", + " Subset 0: () gives pval = 0.63485 / val = -0.365\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V7 (18/21):\n", + " Subset 0: () gives pval = 0.27239 / val = 0.728\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V7 (19/21):\n", + " Subset 0: () gives pval = 0.66667 / val = -0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V7 (20/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V7 (21/21):\n", + " Subset 0: () gives pval = 0.62418 / val = -0.376\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V7\n", + "\n", + "## Resulting lagged parent (super)sets:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.02381, |min_val| = 0.976\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "##\n", + "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", + "##\n", + "\n", + "Parameters:\n", + "\n", + "independence test = par_corr\n", + "tau_min = 0\n", + "tau_max = 3\n", + "pc_alpha = 0.025\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "reset_lagged_links = False\n", + "max_conds_dim = None\n", + "max_conds_py = None\n", + "max_conds_px = None\n", + "max_conds_px_lagged = None\n", + "fdr_method = none\n", + "\n", + "--------------------------\n", + "Skeleton discovery phase\n", + "--------------------------\n", + "\n", + "Testing contemporaneous condition sets of dimension 0: \n", + "\n", + " Link (V1 0) o?o V2 (1/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V2 -2) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.33446 / val = -0.865\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V3 (2/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.20111 / val = 0.799\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V4 (3/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.65550 / val = 0.345\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V5 (4/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.60053 / val = -0.399\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V6 (5/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.92839 / val = -0.072\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V7 (6/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.62790 / val = 0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V1 (7/43):\n", + " Already removed.\n", + "\n", + " Link (V2 -2) -?> V2 (8/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -4) ]\n", + " Subset 0: () gives pval = 0.16206 / val = -0.968\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V3 (9/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.73228 / val = -0.408\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V4 (10/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.85995 / val = -0.218\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V5 (11/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.36193 / val = 0.843\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V6 (12/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.62384 / val = 0.557\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V7 (13/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.40777 / val = -0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V1 (14/43):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V2 (15/43):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V4 (16/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.35534 / val = 0.645\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V5 (17/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.92687 / val = 0.073\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V6 (18/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.49748 / val = 0.503\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V7 (19/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.82592 / val = -0.174\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V1 (20/43):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V2 (21/43):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V3 (22/43):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V5 (23/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.80554 / val = -0.194\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V6 (24/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.19822 / val = 0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V7 (25/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V1 (26/43):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V2 (27/43):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V3 (28/43):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V4 (29/43):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V6 (30/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.59577 / val = 0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V7 (31/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.01980 / val = -0.980\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V6 0) o?o V1 (32/43):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V2 (33/43):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V3 (34/43):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V4 (35/43):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V5 (36/43):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V7 (37/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.42265 / val = -0.577\n", + " Non-significance detected.\n", + "\n", + " Link (V7 0) o?o V1 (38/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V2 (39/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V3 (40/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V4 (41/43):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V5 (42/43):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.01980 / val = -0.980\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V7 0) o?o V6 (43/43):\n", + " Already removed.\n", + "\n", + "Updated contemp. adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 1 link(s):\n", + " (V7 0): max_pval = 0.01980, |min_val| = 0.980\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 1 link(s):\n", + " (V5 0): max_pval = 0.01980, |min_val| = 0.980\n", + "\n", + "Algorithm converged at p = 0.\n", + "\n", + "----------------------------\n", + "Collider orientation phase\n", + "----------------------------\n", + "\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 1 link(s):\n", + " (V7 0)\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 1 link(s):\n", + " (V5 0)\n", + "\n", + "\n", + "----------------------------\n", + "Rule orientation phase\n", + "----------------------------\n", + "\n", + "Try rule(s) [1 2 3]\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 1 link(s):\n", + " (V7 0)\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 1 link(s):\n", + " (V5 0)\n", + "\n", + "## Significant links at alpha = 0.025:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 1 link(s):\n", + " (V7 0): pval = 0.01980 | val = -0.980 | unoriented link\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 1 link(s):\n", + " (V5 0): pval = 0.01980 | val = -0.980 | unoriented link\n", + "\n", + "## pc_alpha = 0.05 (5/5):\n", + "\n", + "##\n", + "## Step 1: PC1 algorithm for selecting lagged conditions\n", + "##\n", + "\n", + "Parameters:\n", + "independence test = par_corr\n", + "tau_min = 1\n", + "tau_max = 3\n", + "pc_alpha = [0.05]\n", + "max_conds_dim = None\n", + "max_combinations = 1\n", + "\n", + "\n", + "\n", + "## Variable V1\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V1 (1/21):\n", + " Subset 0: () gives pval = 0.76612 / val = -0.234\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V1 (2/21):\n", + " Subset 0: () gives pval = 0.52792 / val = -0.472\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V1 (3/21):\n", + " Subset 0: () gives pval = 0.19791 / val = -0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V1 (4/21):\n", + " Subset 0: () gives pval = 0.07702 / val = 0.923\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V1 (5/21):\n", + " Subset 0: () gives pval = 0.96797 / val = -0.032\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V1 (6/21):\n", + " Subset 0: () gives pval = 0.09642 / val = -0.904\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V1 (7/21):\n", + " Subset 0: () gives pval = 0.44848 / val = -0.552\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V1 (8/21):\n", + " Subset 0: () gives pval = 0.68330 / val = 0.317\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V1 (9/21):\n", + " Subset 0: () gives pval = 0.54066 / val = 0.459\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V1 (10/21):\n", + " Subset 0: () gives pval = 0.29779 / val = -0.702\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V1 (11/21):\n", + " Subset 0: () gives pval = 0.52864 / val = -0.471\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V1 (12/21):\n", + " Subset 0: () gives pval = 0.20579 / val = 0.794\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V1 (13/21):\n", + " Subset 0: () gives pval = 0.39236 / val = 0.608\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V1 (14/21):\n", + " Subset 0: () gives pval = 0.67772 / val = -0.322\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V1 (15/21):\n", + " Subset 0: () gives pval = 0.21445 / val = 0.786\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V1 (16/21):\n", + " Subset 0: () gives pval = 0.07663 / val = -0.923\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V1 (17/21):\n", + " Subset 0: () gives pval = 0.90942 / val = -0.091\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V1 (18/21):\n", + " Subset 0: () gives pval = 0.24793 / val = 0.752\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V1 (19/21):\n", + " Subset 0: () gives pval = 0.95866 / val = 0.041\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V1 (20/21):\n", + " Subset 0: () gives pval = 0.02837 / val = -0.972\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V7 -3) -?> V1 (21/21):\n", + " Subset 0: () gives pval = 0.95338 / val = 0.047\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V1 has 1 link(s):\n", + " (V7 -2): max_pval = 0.02837, |min_val| = 0.972\n", + "\n", + "Algorithm converged for variable V1\n", + "\n", + "## Variable V2\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V2 (1/21):\n", + " Subset 0: () gives pval = 0.10887 / val = -0.891\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V2 (2/21):\n", + " Subset 0: () gives pval = 0.95900 / val = -0.041\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V2 (3/21):\n", + " Subset 0: () gives pval = 0.35587 / val = 0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V2 (4/21):\n", + " Subset 0: () gives pval = 0.84212 / val = -0.158\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V2 (5/21):\n", + " Subset 0: () gives pval = 0.02381 / val = -0.976\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V2 -3) -?> V2 (6/21):\n", + " Subset 0: () gives pval = 0.49923 / val = 0.501\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V2 (7/21):\n", + " Subset 0: () gives pval = 0.83019 / val = -0.170\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V2 (8/21):\n", + " Subset 0: () gives pval = 0.14931 / val = 0.851\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V2 (9/21):\n", + " Subset 0: () gives pval = 0.93518 / val = -0.065\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V2 (10/21):\n", + " Subset 0: () gives pval = 0.57191 / val = -0.428\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V2 (11/21):\n", + " Subset 0: () gives pval = 0.05965 / val = 0.940\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V2 (12/21):\n", + " Subset 0: () gives pval = 0.67197 / val = 0.328\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V2 (13/21):\n", + " Subset 0: () gives pval = 0.31401 / val = -0.686\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V2 (14/21):\n", + " Subset 0: () gives pval = 0.38770 / val = 0.612\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V2 (15/21):\n", + " Subset 0: () gives pval = 0.57992 / val = 0.420\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V2 (16/21):\n", + " Subset 0: () gives pval = 0.95332 / val = -0.047\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V2 (17/21):\n", + " Subset 0: () gives pval = 0.00295 / val = 0.997\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V6 -3) -?> V2 (18/21):\n", + " Subset 0: () gives pval = 0.89811 / val = 0.102\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V2 (19/21):\n", + " Subset 0: () gives pval = 0.29986 / val = -0.700\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V2 (20/21):\n", + " Subset 0: () gives pval = 0.92687 / val = 0.073\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V2 (21/21):\n", + " Subset 0: () gives pval = 0.02116 / val = 0.979\n", + " No conditions of dimension 0 left.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V2 has 3 link(s):\n", + " (V6 -2): max_pval = 0.00295, |min_val| = 0.997\n", + " (V7 -3): max_pval = 0.02116, |min_val| = 0.979\n", + " (V2 -2): max_pval = 0.02381, |min_val| = 0.976\n", + "\n", + "Testing condition sets of dimension 1:\n", + "\n", + " Link (V6 -2) -?> V2 (1/3):\n", + " Subset 0: (V7 -3) gives pval = 0.20519 / val = 0.949\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V2 (2/3):\n", + " Subset 0: (V6 -2) gives pval = 0.64098 / val = -0.535\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V2 (3/3):\n", + " Subset 0: (V6 -2) gives pval = 0.00000 / val = 1.000\n", + " No conditions of dimension 1 left.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.02381, |min_val| = 0.976\n", + "\n", + "Algorithm converged for variable V2\n", + "\n", + "## Variable V3\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V3 (1/21):\n", + " Subset 0: () gives pval = 0.75382 / val = -0.246\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V3 (2/21):\n", + " Subset 0: () gives pval = 0.84711 / val = 0.153\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V3 (3/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V3 (4/21):\n", + " Subset 0: () gives pval = 0.48971 / val = 0.510\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V3 (5/21):\n", + " Subset 0: () gives pval = 0.86516 / val = 0.135\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V3 (6/21):\n", + " Subset 0: () gives pval = 0.37746 / val = -0.623\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V3 (7/21):\n", + " Subset 0: () gives pval = 0.11338 / val = -0.887\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V3 (8/21):\n", + " Subset 0: () gives pval = 0.67814 / val = 0.322\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V3 (9/21):\n", + " Subset 0: () gives pval = 0.83884 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V3 (10/21):\n", + " Subset 0: () gives pval = 0.76348 / val = -0.237\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V3 (11/21):\n", + " Subset 0: () gives pval = 0.59220 / val = -0.408\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V3 (12/21):\n", + " Subset 0: () gives pval = 0.64658 / val = 0.353\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V3 (13/21):\n", + " Subset 0: () gives pval = 0.14720 / val = 0.853\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V3 (14/21):\n", + " Subset 0: () gives pval = 0.23881 / val = -0.761\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V3 (15/21):\n", + " Subset 0: () gives pval = 0.59382 / val = 0.406\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V3 (16/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V3 (17/21):\n", + " Subset 0: () gives pval = 0.80931 / val = -0.191\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V3 (18/21):\n", + " Subset 0: () gives pval = 0.78890 / val = 0.211\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V3 (19/21):\n", + " Subset 0: () gives pval = 0.47777 / val = 0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V3 (20/21):\n", + " Subset 0: () gives pval = 0.36364 / val = -0.636\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V3 (21/21):\n", + " Subset 0: () gives pval = 0.96075 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V3\n", + "\n", + "## Variable V4\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V4 (1/21):\n", + " Subset 0: () gives pval = 0.45446 / val = 0.546\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V4 (2/21):\n", + " Subset 0: () gives pval = 0.63860 / val = 0.361\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V4 (3/21):\n", + " Subset 0: () gives pval = 0.44451 / val = -0.555\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V4 (4/21):\n", + " Subset 0: () gives pval = 0.86082 / val = 0.139\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V4 (5/21):\n", + " Subset 0: () gives pval = 0.16334 / val = 0.837\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V4 (6/21):\n", + " Subset 0: () gives pval = 0.50949 / val = -0.491\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V4 (7/21):\n", + " Subset 0: () gives pval = 0.62576 / val = -0.374\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V4 (8/21):\n", + " Subset 0: () gives pval = 0.51092 / val = -0.489\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V4 (9/21):\n", + " Subset 0: () gives pval = 0.71429 / val = -0.286\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V4 (10/21):\n", + " Subset 0: () gives pval = 0.58069 / val = 0.419\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V4 (11/21):\n", + " Subset 0: () gives pval = 0.18066 / val = -0.819\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V4 (12/21):\n", + " Subset 0: () gives pval = 0.71082 / val = -0.289\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V4 (13/21):\n", + " Subset 0: () gives pval = 0.05509 / val = 0.945\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V4 (14/21):\n", + " Subset 0: () gives pval = 0.06126 / val = -0.939\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V4 (15/21):\n", + " Subset 0: () gives pval = 0.69139 / val = -0.309\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V4 (16/21):\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V4 (17/21):\n", + " Subset 0: () gives pval = 0.15485 / val = -0.845\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V4 (18/21):\n", + " Subset 0: () gives pval = 0.77546 / val = -0.225\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V4 (19/21):\n", + " Subset 0: () gives pval = 0.07418 / val = 0.926\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V4 (20/21):\n", + " Subset 0: () gives pval = 0.83884 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V4 (21/21):\n", + " Subset 0: () gives pval = 0.23452 / val = -0.765\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V4\n", + "\n", + "## Variable V5\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V5 (1/21):\n", + " Subset 0: () gives pval = 0.40591 / val = -0.594\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V5 (2/21):\n", + " Subset 0: () gives pval = 0.22108 / val = 0.779\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V5 (3/21):\n", + " Subset 0: () gives pval = 0.18784 / val = 0.812\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V5 (4/21):\n", + " Subset 0: () gives pval = 0.33692 / val = -0.663\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V5 (5/21):\n", + " Subset 0: () gives pval = 0.56614 / val = -0.434\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V5 (6/21):\n", + " Subset 0: () gives pval = 0.27666 / val = 0.723\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V5 (7/21):\n", + " Subset 0: () gives pval = 0.49057 / val = -0.509\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V5 (8/21):\n", + " Subset 0: () gives pval = 0.44520 / val = 0.555\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V5 (9/21):\n", + " Subset 0: () gives pval = 0.15734 / val = -0.843\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V5 (10/21):\n", + " Subset 0: () gives pval = 0.66704 / val = 0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V5 (11/21):\n", + " Subset 0: () gives pval = 0.27833 / val = 0.722\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V5 (12/21):\n", + " Subset 0: () gives pval = 0.62823 / val = -0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V5 (13/21):\n", + " Subset 0: () gives pval = 0.82850 / val = -0.171\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V5 (14/21):\n", + " Subset 0: () gives pval = 0.86689 / val = -0.133\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V5 (15/21):\n", + " Subset 0: () gives pval = 0.76662 / val = -0.233\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V5 (16/21):\n", + " Subset 0: () gives pval = 0.48656 / val = 0.513\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V5 (17/21):\n", + " Subset 0: () gives pval = 0.46312 / val = 0.537\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V5 (18/21):\n", + " Subset 0: () gives pval = 0.35473 / val = -0.645\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V5 (19/21):\n", + " Subset 0: () gives pval = 0.85997 / val = 0.140\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V5 (20/21):\n", + " Subset 0: () gives pval = 0.48811 / val = 0.512\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V5 (21/21):\n", + " Subset 0: () gives pval = 0.46322 / val = 0.537\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V5\n", + "\n", + "## Variable V6\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V6 (1/21):\n", + " Subset 0: () gives pval = 0.72783 / val = 0.272\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V6 (2/21):\n", + " Subset 0: () gives pval = 0.15485 / val = 0.845\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V6 (3/21):\n", + " Subset 0: () gives pval = 0.96151 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V6 (4/21):\n", + " Subset 0: () gives pval = 0.60943 / val = -0.391\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V6 (5/21):\n", + " Subset 0: () gives pval = 0.40372 / val = 0.596\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V6 (6/21):\n", + " Subset 0: () gives pval = 0.92353 / val = 0.076\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V6 (7/21):\n", + " Subset 0: () gives pval = 0.48656 / val = -0.513\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V6 (8/21):\n", + " Subset 0: () gives pval = 0.74584 / val = -0.254\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V6 (9/21):\n", + " Subset 0: () gives pval = 0.19822 / val = -0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V6 (10/21):\n", + " Subset 0: () gives pval = 0.28091 / val = 0.719\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V6 (11/21):\n", + " Subset 0: () gives pval = 0.66939 / val = -0.331\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V6 (12/21):\n", + " Subset 0: () gives pval = 0.36883 / val = -0.631\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V6 (13/21):\n", + " Subset 0: () gives pval = 0.29289 / val = 0.707\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V6 (14/21):\n", + " Subset 0: () gives pval = 0.08530 / val = -0.915\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V6 (15/21):\n", + " Subset 0: () gives pval = 0.42265 / val = -0.577\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V6 (16/21):\n", + " Subset 0: () gives pval = 0.55095 / val = 0.449\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V6 (17/21):\n", + " Subset 0: () gives pval = 0.47295 / val = -0.527\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V6 (18/21):\n", + " Subset 0: () gives pval = 0.29986 / val = -0.700\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V6 (19/21):\n", + " Subset 0: () gives pval = 0.03775 / val = 0.962\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V7 -2) -?> V6 (20/21):\n", + " Subset 0: () gives pval = 0.69849 / val = 0.302\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V6 (21/21):\n", + " Subset 0: () gives pval = 0.52264 / val = -0.477\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): max_pval = 0.03775, |min_val| = 0.962\n", + "\n", + "Algorithm converged for variable V6\n", + "\n", + "## Variable V7\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V7 (1/21):\n", + " Subset 0: () gives pval = 0.52860 / val = 0.471\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V7 (2/21):\n", + " Subset 0: () gives pval = 0.12169 / val = -0.878\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V7 (3/21):\n", + " Subset 0: () gives pval = 0.26667 / val = -0.733\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V7 (4/21):\n", + " Subset 0: () gives pval = 0.32352 / val = 0.676\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V7 (5/21):\n", + " Subset 0: () gives pval = 0.74180 / val = 0.258\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V7 (6/21):\n", + " Subset 0: () gives pval = 0.33773 / val = -0.662\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V7 (7/21):\n", + " Subset 0: () gives pval = 0.43408 / val = 0.566\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V7 (8/21):\n", + " Subset 0: () gives pval = 0.55977 / val = -0.440\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V7 (9/21):\n", + " Subset 0: () gives pval = 0.07418 / val = 0.926\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V7 (10/21):\n", + " Subset 0: () gives pval = 0.54709 / val = -0.453\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V7 (11/21):\n", + " Subset 0: () gives pval = 0.42736 / val = -0.573\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V7 (12/21):\n", + " Subset 0: () gives pval = 0.53148 / val = 0.469\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V7 (13/21):\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V7 (14/21):\n", + " Subset 0: () gives pval = 0.68314 / val = 0.317\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V7 (15/21):\n", + " Subset 0: () gives pval = 0.66667 / val = 0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V7 (16/21):\n", + " Subset 0: () gives pval = 0.44444 / val = -0.556\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V7 (17/21):\n", + " Subset 0: () gives pval = 0.63485 / val = -0.365\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V7 (18/21):\n", + " Subset 0: () gives pval = 0.27239 / val = 0.728\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V7 (19/21):\n", + " Subset 0: () gives pval = 0.66667 / val = -0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V7 (20/21):\n", + " Subset 0: () gives pval = 0.47777 / val = -0.522\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V7 (21/21):\n", + " Subset 0: () gives pval = 0.62418 / val = -0.376\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V7\n", + "\n", + "## Resulting lagged parent (super)sets:\n", + "\n", + " Variable V1 has 1 link(s):\n", + " (V7 -2): max_pval = 0.02837, |min_val| = 0.972\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.02381, |min_val| = 0.976\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): max_pval = 0.03775, |min_val| = 0.962\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "##\n", + "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", + "##\n", + "\n", + "Parameters:\n", + "\n", + "independence test = par_corr\n", + "tau_min = 0\n", + "tau_max = 3\n", + "pc_alpha = 0.05\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "reset_lagged_links = False\n", + "max_conds_dim = None\n", + "max_conds_py = None\n", + "max_conds_px = None\n", + "max_conds_px_lagged = None\n", + "fdr_method = none\n", + "\n", + "--------------------------\n", + "Skeleton discovery phase\n", + "--------------------------\n", + "\n", + "Testing contemporaneous condition sets of dimension 0: \n", + "\n", + " Link (V1 0) o?o V2 (1/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V2 -2) ]\n", + " with conds_x = [ (V7 -2) ]\n", + " Subset 0: () gives pval = nan / val = 1.000\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V3 (2/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V7 -2) ]\n", + " Subset 0: () gives pval = 0.09117 / val = 0.990\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V4 (3/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V7 -2) ]\n", + " Subset 0: () gives pval = 0.40435 / val = 0.805\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V5 (4/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V7 -2) ]\n", + " Subset 0: () gives pval = 0.67997 / val = 0.482\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V6 (5/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ (V7 -2) ]\n", + " Subset 0: () gives pval = nan / val = 1.000\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V7 (6/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V7 -2) ]\n", + " Subset 0: () gives pval = 0.53188 / val = -0.671\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V1 (7/45):\n", + " Already removed.\n", + "\n", + " Link (V2 -2) -?> V2 (8/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -4) ]\n", + " Subset 0: () gives pval = 0.16206 / val = -0.968\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V3 (9/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.73228 / val = -0.408\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V4 (10/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.85995 / val = -0.218\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V5 (11/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.36193 / val = 0.843\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V6 (12/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = nan / val = 1.000\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V7 (13/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.40777 / val = -0.802\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V1 (14/45):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V2 (15/45):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V4 (16/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.35534 / val = 0.645\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V5 (17/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.92687 / val = 0.073\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V6 (18/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V7 (19/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.82592 / val = -0.174\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V1 (20/45):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V2 (21/45):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V3 (22/45):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V5 (23/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.80554 / val = -0.194\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V6 (24/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.33333 / val = -0.866\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V7 (25/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 1.00000 / val = 0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V1 (26/45):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V2 (27/45):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V3 (28/45):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V4 (29/45):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V6 (30/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.00000 / val = 1.000\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V5 0) o?o V7 (31/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.01980 / val = -0.980\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V6 0) o?o V1 (32/45):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V2 (33/45):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V3 (34/45):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V4 (35/45):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V5 (36/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V7 -1) ]\n", + " Subset 0: () gives pval = 0.00000 / val = 1.000\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V6 0) o?o V7 (37/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V7 -1) ]\n", + " Subset 0: () gives pval = 0.00000 / val = -1.000\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V7 0) o?o V1 (38/45):\n", + " Already removed.\n", + "\n", + " Link (V7 -2) -?> V1 (39/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.02837 / val = -0.972\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V7 0) o?o V2 (40/45):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V3 (41/45):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V4 (42/45):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V5 (43/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.01980 / val = -0.980\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V7 0) o?o V6 (44/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.00000 / val = -1.000\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V7 -1) -?> V6 (45/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.03775 / val = 0.962\n", + " No conditions of dimension 0 left.\n", + "\n", + "Updated contemp. adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 2 link(s):\n", + " (V6 0): max_pval = 0.00000, |min_val| = 1.000\n", + " (V7 0): max_pval = 0.01980, |min_val| = 0.980\n", + "\n", + " Variable V6 has 2 link(s):\n", + " (V5 0): max_pval = 0.00000, |min_val| = 1.000\n", + " (V7 0): max_pval = 0.00000, |min_val| = 1.000\n", + "\n", + " Variable V7 has 2 link(s):\n", + " (V6 0): max_pval = 0.00000, |min_val| = 1.000\n", + " (V5 0): max_pval = 0.01980, |min_val| = 0.980\n", + "\n", + "Testing contemporaneous condition sets of dimension 1: \n", + "\n", + " Link (V5 0) o?o V6 (1/7):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: (V7 0) gives pval = nan / val = -0.939\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V7 (2/7):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: (V6 0) gives pval = 0.00000 / val = -1.000\n", + " No conditions of dimension 1 left.\n", + "\n", + " Link (V6 0) o?o V5 (3/7):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V7 (4/7):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V7 -1) ]\n", + " Subset 0: (V5 0) gives pval = nan / val = -0.778\n", + " Non-significance detected.\n", + "\n", + " Link (V7 0) o?o V5 (5/7):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: (V6 0) gives pval = 0.00000 / val = -1.000\n", + " No conditions of dimension 1 left.\n", + "\n", + " Link (V7 0) o?o V6 (6/7):\n", + " Already removed.\n", + "\n", + " Link (V7 -1) -?> V6 (7/7):\n", + " Iterate through 2 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: (V5 0) gives pval = 0.00000 / val = 1.000\n", + " Subset 1: (V7 0) gives pval = 0.00000 / val = 1.000\n", + " No conditions of dimension 1 left.\n", + "\n", + "Updated contemp. adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 1 link(s):\n", + " (V7 0): max_pval = 0.01980, |min_val| = 0.980\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 1 link(s):\n", + " (V5 0): max_pval = 0.01980, |min_val| = 0.980\n", + "\n", + "Algorithm converged at p = 1.\n", + "\n", + "----------------------------\n", + "Collider orientation phase\n", + "----------------------------\n", + "\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 1 link(s):\n", + " (V7 -2)\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 1 link(s):\n", + " (V7 0)\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1)\n", + "\n", + " Variable V7 has 1 link(s):\n", + " (V5 0)\n", + "\n", + "\n", + "----------------------------\n", + "Rule orientation phase\n", + "----------------------------\n", + "\n", + "Try rule(s) [1 2 3]\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 1 link(s):\n", + " (V7 -2)\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 1 link(s):\n", + " (V7 0)\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1)\n", + "\n", + " Variable V7 has 1 link(s):\n", + " (V5 0)\n", + "\n", + "## Significant links at alpha = 0.05:\n", + "\n", + " Variable V1 has 1 link(s):\n", + " (V7 -2): pval = 0.02837 | val = -0.972\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 1 link(s):\n", + " (V7 0): pval = 0.01980 | val = -0.980 | unoriented link\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): pval = 0.03775 | val = 0.962\n", + "\n", + " Variable V7 has 1 link(s):\n", + " (V5 0): pval = 0.01980 | val = -0.980 | unoriented link\n", + "\n", + "##\n", + "\n", + "## Scores for individual pc_alpha values:\n", + "\n", + " pc_alpha = 0.001 yields score = 7.54518\n", + " pc_alpha = 0.005 yields score = 4.89615\n", + " pc_alpha = 0.01 yields score = 4.89615\n", + " pc_alpha = 0.025 yields score = 5.98022\n", + " pc_alpha = 0.05 yields score = 3.41674\n", + "\n", + "##\n", + "## Results for optimal pc_alpha = 0.05\n", + "##\n", + "\n", + "## Significant links at alpha = 0.05:\n", + "\n", + " Variable V1 has 1 link(s):\n", + " (V7 -2): pval = 0.02837 | val = -0.972\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 1 link(s):\n", + " (V7 0): pval = 0.01980 | val = -0.980 | unoriented link\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): pval = 0.03775 | val = 0.962\n", + "\n", + " Variable V7 has 1 link(s):\n", + " (V5 0): pval = 0.01980 | val = -0.980 | unoriented link\n" + ] + } + ], "source": [ "tau_max = 3\n", "pc_alpha = None\n", @@ -255,9 +6035,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAE9CAYAAACWQ2EXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACSi0lEQVR4nOzdd3xb1f0//pf2sGRbsmzLe+/YjleG7SSO42wSSEhCQsPmUyi/UiijLR/aD59++BbaAqVllRkgYYUsEhISsuMsZ9jx3nsvyUOytu75/RGkxiQhEGzJss/z8dAjPGSh+7460rnveyaLEEJAURRFUdSUxXZ2ABRFURRFORdNBiiKoihqiqPJAEVRFEVNcTQZoCiKoqgpjiYDFEVRFDXF0WSAoiiKoqY4mgxQFEVR1BRHkwGKoiiKmuJoMkBRFEVRUxxNBiiKoihqiqPJAEVRFEVNcTQZoCiKoqgpjuvsAMYSIQQMw8BqtcJiscBqtdqfs+3HxGazwWKxwGazwWazweVyweFwwOFwnBw9BcBeTrbys1qt9vKz/ctisewPNpsNDocDHo8HDocDFovl5DOggP+Uo9lsHvVbtJUj8J/f4pXlyOVyweVOqmrJpdnK68rf4w/Vqba6lNaprsflfnVXVihXXiRsD51Oh4GBAahUKgwNDcFqtUKv18NsNgMAhEIh+Hw+hEIhpFIpPD094enpCYlEclWiYPtvW4VFjQ1bJfL9Mryy4lGr1RgYGMDw8DBGRkbAMAy0Wi0sFgv4fL79IRQK4e7uDh8fH3h4eIDH440qN1tZstmXG8FoOY6d75fj98vTYrGgr68PfX190Gg0MJvNMJvN0Ov1sFqtEIlE4PP5EAgEEIlEcHd3h0KhgKen53XL0FZ+tBzHzg/VqVarFSMjIxgYGIBarcbw8DCsVit0Oh3MZjPYbDYEAsGo36JcLoeHhwfc3NxGJXu0Tp3YXC4ZMJlMaG9vR01NDWpra1FdXY3Kykq0trZCpVJBp9PZ7zx+LDabDZFIBD8/P0RHRyMmJgbh4eGIjIxEVFQUwsPD7Xek1NgwGAwoLi5GbW0tGhsb0djYiIaGBjQ3N6Ovrw8Wi+Unvyefz4dMJoOfnx9CQ0MRExOD+Ph4TJs2DeHh4fDw8BiHM5m6rFYrNBoNSkpKUF5ejurqajQ2NqK1tRU9PT0YGBiA1Wr9ye8rFArh7++P0NBQhIWFISwsDBEREUhMTERcXBz9HY4xo9GI5uZm1NbWor6+HjU1NaisrERLSwtUKhX0ej1+6k73HA4HYrEYSqUS0dHRiI2NtdenkZGRCA4OHqezoW4Wi/zUUnYgQgh0Oh3Ky8tx9OhRnD9/HlVVVVCpVGAYBhKJBBEREYiIiEBgYCC8vLwgk8kgl8vh5eUFT09PsNlse2sAcPkiZDKZYDQaodFo7HegarUavb299gtSe3s7tFotuFwuFAoFZsyYgVmzZiErKwuhoaGQSqVO/nRcB8MwaGlpQVlZGS5cuIDCwkIUFxdDr9dDKBTC29sbQUFBCAoKQkhICLy9vaFQKCCTyeDu7g43Nzew2WxIJBJwOByYTCaYzWaYTCaYTCYMDg6ip6cHarUaKpUKvb29aGtrQ3NzMxobG8EwDDw8PBASEoLExESkpaVh4cKF8PPzo02ZP5Lt7vHSpUs4c+YMiouLUVVVhcbGRhgMBkgkEoSHhyMoKAj+/v7w9fWFXC6Hj48PvL294e7uDi6XCx6PB5FIBA6HA71eby9DnU6H4eFh9Pf3o6+vDz09PWhra0N7ezs6OjrQ1dUFQgh8fHyQkpKC5ORkpKamYvr06fD19XX2x+MyCCEYHh5GRUUFTpw4gbNnz6KyshKDg4MAAHd3d4SGhiIyMhJBQUGj6lTbHb/t5onH44EQAqPRaK9Th4aGrqpTGxsb0dTUhLa2Nuj1evD5fHh7eyMtLQ2ZmZmYN28eAgMD4ebm5twPZ4qbkMlAXV0dioqKUFxcjMrKSrS3t0MgECAoKAgBAQEICQlBcHAwvL294ebmBrFYbP9yfv8BYFQz8ZXNmVar1d50aTabYTQaodPp7I++vj60tbWhoaEBbW1taGtrA4/HQ0BAAGJiYpCeno65c+fCy8uL3q18j8ViQVVVFY4dO4aLFy+itbUVIyMjEIvFCAwMRGhoKOLi4qBUKiGVSiEUCiESiexNx3w+Hzwezz6mA4B9TMC1uhWMRuOoctTr9dDr9dBoNGhqakJzc7P9otLd3Q2RSISEhASkpqYiPT0dMTExcHd3d/KnNvH09vaiuroa586dw7lz59Dc3AwejweFQgE/Pz8EBgYiJiYG/v7+9t+hUCiEQCAAj8ezlyWXy7U3DdvK88pmads4H1uSZytDg8EAvV6P4eFhNDU1obq6Gu3t7eju7obRaIS7uztiYmKQnZ2NnJwceHt723/31H9UV1fjwoULKC4uRk1NDbq6uiAQCBAcHIygoCCEhYXZb6jEYrG9LG2/Q9tv0fbZXjk+58o61VaGtoct0dPpdBgZGUFPTw9aW1vR3Nxsr1NtccTFxSE1NRVZWVmQy+W0TnWwCZEMMAwDvV6PiooKFBYWoqysDL29vTAajeDz+fDz80NMTAwCAwPh7+8PpVIJLy8vSCSScY1pZGQE/f396Orqsn+Bm5qaoFarYTQaweFwEBERgdTUVCQnJyM4OHhKtxiYzWZ0dXWhtrYWFRUVKC4uRl9fH9hsNuRyOfz8/BASEoKAgAB7JSSVSset8rbdzdruNLu7u9HV1YW2tjbU1tZiaGgIDMNAoVAgLCwMCQkJmD59OsLDw6dsRUQIgclkQkVFBSorK1FdXY3m5mYMDg6Cw+EgICAA4eHh9t+hUqlEQEAA3N3dx+0zI4TYxx+0traio6MDHR0d9lYDjUYDQggiIyMRFxeHuLg4REREwN/ff1zicQW2vv7Kykr7jVV/fz/MZjOEQiH8/PwQFRWF4OBgBAQEQKlUQi6XQywWj1tMDMNAo9HY69T29nY0NTWhoaEBg4ODMJlM4PP5CAsLQ2pqKlJSUhAcHDyuMVH/4dRkwGq1Ynh4GF1dXaivr8eRI0dw4cIFmEwmhISEICEhAcnJyUhLS0NISIjTK2iz2Yy6ujpUVFSgtLQUpaWlaGtrQ0BAANLS0pCSkoLIyEj7DwuY/AOdbHd13d3daGpqQklJCQoLC1FVVQWz2Wy/805OTkZERAS8vb2dHq/JZEJpaSnOnTuHwsJCNDc3w2AwICAgABkZGcjOzkZwcDAUCgWEQuGkL0PgckVtMpnQ3d2NmpoaHDlyBCUlJRgYGIBYLMa0adMwa9YszJo1C0FBQRAIBE6N12q1oq+vD9XV1SgsLMTp06fR2toKLy8vREVFISkpCdOnT0dISAh8fHwATP7fInD5cxkYGEBnZyfq6upw4sQJe50aFRWFadOmISkpCcnJyQgJCXFqrLYkr6qqCmVlZSgrK0N5eTk6OzsRGBiIjIwMpKenIywsDL6+vvaBpdT4cHgyYDucwWDAwMAALly4gAMHDuDAgQOwWCxYuHAhbrvtNsyYMQNKpdKRof0kttHtx44dw2effYYzZ85ALBYjIyMDt956K3Jzc+39pJPxC2y769br9ejr68OOHTuwa9cutLW1QSaTYc6cOVi7di2ysrImdL+82WxGTU0NTp48if379+PMmTMIDAzEL37xC+Tl5SEiIgJisXjSTncjhMBsNkOr1aKtrQ27d+/GRx99BLPZjPT0dMyfPx85OTlISkpydqjXZTuHo0ePYu/evTh79ix6enoQEhKC++67DytXrrTPNLF1F04mV9apKpUKp0+fxv79+3HixAkwDIOFCxdizZo1mDFjhv0mZSKyWq0YHBxEfn4+PvvsM5w6dQqenp6YM2cOli9fjjlz5kAqlU7aOtXpiAMxDEMYhiEWi4V88MEHJD09nXh6epLExETywgsvEJVKRRiGcWRIY6a8vJw8++yzJDk5mbi5uZGsrCxy7tw5YjKZ7Oc9WTAMQ6xWK+nt7SX//Oc/iZeXF3F3dyf33HMP2bt3LxkaGnJ2iDfFZDKRixcvklWrVhGpVErCw8PJY489RkpLS+1lONnK0WKxkMOHD5MHHniAyOVyIpPJyLPPPktaW1uJyWRydog3paOjg3z55Zdk8eLFhMVikfT0dPLVV1+R3t7eSVmGtnJ85513SFxcHPH09CQzZ84k//jHP1y6Ti0pKSGPPfYYiYmJIR4eHiQ3N5ecO3eOWCyWSVeOE4FDk4GRkRFSUFBAsrOzibu7O1m3bh3Ztm0b6e3tdfmLptVqJUajkbS3t5MdO3aQOXPmEJFIRP7rv/6LFBYWEr1e7+wQx0xzczN54403SFpaGnF3dyePP/44qa2tJVqt1v5DdUW2JMdgMJCioiLy+OOPk/j4eOLv70+eeOIJMjAwQKxWq7PDHBMMw5Di4mKyZs0aEhQURFJSUsjzzz9POjo6iNFoJFar1aXL0Ww2E41GQ06fPk0WLFhA5HI5Wbx4Mdm0aRMZHh52dohjZnh4mOTn55Ps7GwikUjI3XffTfbv30/6+/snTZ3a1NRENm/eTLKysohIJCKPPPIIqa6uJgaDwdkhTioO6SYghKCmpga7d+/G5s2bIZfL8atf/Qqpqanw8/OzTxmbDCwWC3Q6Hbq6urBjxw5s3boVHh4eWLlyJVatWoWIiAhnh3hTbF+TXbt24bPPPkNjYyNCQkJw7733IiMjAwqFwr7gz2RgMBigVqtRXl6Ow4cPY8+ePQgKCsJzzz2H5ORklx0oSr7r2vniiy/w6quvQiqVYtmyZcjJyUF0dDTkcvmkWcnRdq5dXV04cOAA9u/fj66uLsTFxeHpp59GUlKSy54n+W6a5549e7B9+3bIZDL85je/QUpKCpRKpX365mRg68bq7OzE7t278emnn8Lb2xsbNmzAkiVLnD72YbIY92RAr9fjyJEjOHjwIEpLS6FUKrF+/XrMnj0bcrl8Uk4DIt/1p9fX1+PEiRP45ptvoNPpEBcXh1WrVmHevHnODvEnsc32+PDDD7Fv3z6w2WwkJSUhNzcX6enpk3ZgD/luTnZDQwNOnTqFL774Ar6+vli5ciXmzJmDyMhIZ4f4k5hMJjQ1NeGrr77C119/bT+XGTNmIDg4eFLO87ZVby0tLSguLsbJkydx4cIFKJVKPPjgg5g3b57TB0P+VDqdDvv27cOhQ4dQX18Pf39/rFmzBtnZ2fD09JyU41vIdwOVGxsbcfToUezZsweEEEyfPh233HILsrKynB2iyxu3b40tKz927Bi2b9+O5uZmBAcHY/369Vi6dCmAyTu61zafOjo62j7/+uDBg7h06RJ0Oh3EYjFSU1NHLa86UdkG9Rw5cgSff/45JBIJ8vLykJeX59J3Vj8Gi8WCh4cHkpOTERYWBoPBgD179mDPnj3QarVYtGgRoqOjXeIzMBgMqKqqwqFDh7B7927IZDLcddddyM3NhVQqdYlzuBm28woNDYWvry8CAgIgEonw7bff4uOPP4ZAIEBycjI8PDwm/GdAvluE7fDhw9i2bRv6+voQHR2N22+/HQsXLgQwuetULpeLqKgo+Pn5gcfj4dtvv8X58+eh1WohEAiQmppKlzn+GcalZYB8N7q3qKgIzz77LIaGhrBgwQI88MADiI6OHuvDTXiEEBQVFWH79u344osvkJ2djf/3//4f/P39J/TIWNs0pQsXLuDpp5+GVCrFn//8Z2RkZEAmkzk7PIey/Uw+//xzvP3227BarVi4cCEeeugh+6yXiVqOthkTW7ZswYEDB6BUKvHSSy9h2rRpk3J0/Q8hhGBwcBBffvklnn/+eWRmZuJXv/oV0tLSJnRSRL6bEltUVIQnnngCVqsVt912G9avX4/w8HBnh+dwhBCcPn0aX375Jfbv34+srCz8v//3/6BUKidNN5fDjfUgBIZhiMlkIhUVFSQ0NJQkJiaSTz/9lAwMDIz1oVxOT08P+fjjj4lEIiG33XYbqa+vn7AD7hiGsccbHBxMUlJSSFNTk8uOMB9Lp0+fJvfccw8JDg4m9957LzEYDBNyoJYtptraWrJs2TISHR1NHnjgAdLV1eXs0JzOYrGQr776igQEBJC5c+eSzZs3E6PROOHKkJDL5ajX60lxcTEJDAwkSUlJZN++fS47a2cstba2krfeeou4u7uT1atXk66uLpce/OpMY54M2L60kZGRJCMjg5SUlNgry6mOYRhiMBjIsWPHiKenJ1mzZg3Jz8+fkJ9Nf38/ee6550hcXBxZunQp6e/vn5AXPGdgGIY0NTWRV199lcjlcvLggw9OyO+41WolnZ2dJC0tjaSkpJA33niDDA0NTbg4ncH2XT59+jSZM2cOycjIIH//+98n5GczMjJC8vPz7XVqQ0PDhE1cHI1hGKLVasmhQ4eIRCIhd955JykpKaGfzU0Y02TAZDKR48ePk9zcXBIbG0uKi4uJXq+nBXMFW5a/efNmEhsbS+6++25y4MABZ4c1ik6nI4899hjJyMggGzZsINXV1TTb/h6z2Uyam5vJ66+/Tjw9Pcnf//530tfX5+yw7KxWK1Gr1WTRokUkLi6ObN26lfT09EyaqZFjxWAwkAMHDpA777yTTJ8+nfz73/92dkijGI1G8tVXX5GcnBySmJhIysrKaCLwPVarlYyMjJCPPvqIhISEkEceeYScPHnS2WG5nDEdQHjhwgV89dVX6O7uxh//+EdER0dDIBDQ/psrsFgsCAQCLFy4EHV1dTh9+jR2796N8PBwREVFOTs8AJf7xc+dO4ekpCRs2LABYWFhU65v+Ua4XC6USiWWLl2K8vJybNmyBQkJCZg1a9aEWOVNpVLhs88+Q3l5OZ577jlkZmZCLpfTcvwegUCAjIwM+z4VH330EbKzsxEfHz8hPqv8/Hzs27cPGo0G//3f/42oqKhJNYV3LNh2UVy8eDEqKipw9uxZeHp6IiAgAGFhYc4Oz2WM2be9s7MTx48fR2lpKbKysrB06dIps677T8VisaBUKrFq1SqEhoairq4Oe/bsgdFo/Mn7ho8lhmHQ2NiIrVu3wsfHB7m5uZgxY4Z9+2dqNNtua3fddRcYhsHevXtRXV0Ns9ns1LiGh4dRXl6O7du3IzMzE0uWLIGvr++knHI2FuRyOWbPno28vDxotVp8+umnGBkZAcMwTo2rra0NBw8eRHNzM+bMmYPFixeDz+fTOvUabHXq2rVr4evri9LSUhw4cABGo9HZobmMMakdGIbB2bNnce7cOXC5XNxzzz3jcnek1+vR3NyMkZGRUc8LBAJERkZCJBLZnyPfzUutqKgYVTlzOBwkJiZiYGAAw8PD0Ov1MJvNIISAx+PBzc0N3t7eEIlE4155pqSkYNGiRfjyyy+xfft2LF++HDExMeN6zOsh380AOXDgACorK/GHP/wBmZmZY764jm3NgqqqqlHPs9lsCIVCxMfHX/V6g8GAysrKUc/7+vrC398fOp0OarUaGo3GXs5cLhcCgQBeXl7jvmEUj8dDZmYmVqxYgT179iA8PByhoaFO2zGPEILW1lYcPXoUjY2N+N///V8olcoxX8/DZDJBpVKho6Nj1PM8Hg++vr5X7StitVrR3t6Ovr6+Uc8nJiZec55/Y2MjhoeHIRaLoVAoxr21JSgoCPPmzUNxcTE2b96MdevWIS4uDkKhcFyPey3ku3VK8vPzUVhYCIVCgfXr14/5DB7y3fTvxsZGGAyGUX8TCASIiYkZdSNgq1PLyspgtVrtz/P5fCQmJqK2tvYHkyiZTAZvb+9x3So8IyMDS5Yswc6dO7F7924sWLBgSs5guylj0deg1WrJqlWrSF5eHvnXv/41Fm95TRUVFSQ3N5cIhULC4XAIAMLj8UhCQgKpqqoa9VqGYcjAwACJiooifD6f8Hg8IhAIiL+/P+nq6iJvvPEGWbNmDUlMTCRKpZL4+PiQadOmkTvuuIPs37+f9PT0EIvFMm7nYjMyMkI+/PBDEhsbS5588kmnzS6wWCykp6eHhIWFkY0bN5KamppxOY5erycXLlwgUqmU8Hg8wmKxCJvNJh4eHiQ7O/uq1xuNRlJcXEwkEgnhcDiEz+cTsVhMfve73xGVSkX27dtHHn74YTJ9+nTi6+tLlEoliYmJIYsXLybvv/8+GRkZGfd+ctt3LScnh6xcuZJs3rzZaX3zer2ebNq0iSQlJZGHH3543L5LbW1t5KWXXiJubm6Ey+Xaf4thYWHkH//4x1WvHx4eJr/5zW+ISCQiXC6X8Pl8IpFISFNT06jX2WYjrVmzhshkMrJ48WLyxRdfjMs5fJ/JZCKNjY0kICCA/PrXvyatra1O+S3aBsXNnz+fLFu2jHz44YfjdpyysjKSmppKBAKBvU7l8/kkMTGRdHZ2XvX6gYEB4ufnR3g8HuHxeEQoFJK4uDhisVjI3LlziVAoJACu+VizZg05ePDguJzLlTQaDXnppZdIcnIyeeaZZ+h4px9pTJKBt956i8TExJD/+Z//Ib29vWPxltdkGwG8Z88esnTpUiISicizzz573QE1ttc///zz5OGHHyZbtmwhWq2WPPDAA0QkEpEnnniCnDhxgvT19RG1Wk2OHTtGpk2bRoRCIfnd735HSkpKxu1croyxsrKSPPvss8Td3Z00NjYSs9k87sf9vu7ubvLXv/6ViEQiUlpaOm7rfl+54c8TTzxBAgMDSWZmJnn33Xd/sAzNZjO57bbbyJ///GdSU1NDVCoV+eKLLwiXyyV5eXmkoKCAqNVq0t3dTb7++muycuVKwmKxyG9/+1uHDOxjGIZ8+umnZO7cuWTt2rWkvb193I95Ld988w1Zv349SU1NJW1tbeNWCdrKpauri9x7770EAHn00UdJZWXlD5bj6dOnydq1a8nf//73aya+RqORfPzxx0QsFhMADk0GGIYhOp2O/Otf/yLu7u5k//79TtnHgGEY8q9//YsEBQWR119/nahUqnE9FsMwZMuWLSQnJ4d4enqSP/3pT9e8gF75233qqafIb37zG7Jjxw77RkkTJRlgGIZcuHCB/Pa3vyW+vr6kubmZDpz9EX7WmAFCCBiGwQcffIC0tDRkZWXBy8vr57zlD7KtLjVt2jQsWLAARqMRW7duvW4fLYvFglqtRmFhIXg8HhYsWGD/29q1a/Hggw/al0X28PBAZmYm3n77bchkMmzduhXffPPNuJ3LlTFGRERgzZo1kMlk2LRpE/R6/bgf90qEEPT09ODjjz/Gfffdh9DQ0HEbJ2ArQxaLhVWrViEgIABVVVU4evToNcdLsFgsMAyDvr4+HDt2DAsXLkRAQID9bxKJBB988AFSU1Ph4eEBb29v5OXl4S9/+Qs8PT2xadMmqFSqUc2a43VeK1euRGpqKnp7e7F9+/ZxPd61MAyDQ4cOobe3F2vWrIGfn9+4HctWhu7u7li/fj1YLBa+/vrrq7oNrnz9yMgIGhoaUFZWhrVr1161AqfZbEZbWxv++7//G0uWLIFCoRi3+K8Xo0AgwL333gtfX198/fXXV3VnjTfyXVP8u+++O2q57/FiK8eMjAxkZ2dDq9Vi27Zt1/y92F6rUqlw7tw5eHl5ITs7e1QZbt68GXV1dejv77/qsWnTJocsxc5isZCYmIgVK1bY6wdnj+NxBT8rGWAYBhcvXkRzczMyMzMRGxvrkBG4fn5+SEpKglKpRFtbG4qKiq57AT1+/DjEYjEiIyOhUCggFArx9NNP47//+78RGhpq3+OczWaDx+MhOTkZEokEvb296Ovrc8iAPh6PBx8fHyxatAh79uxx+OCl3t5elJSUoKurC7fffrvDBn4mJSUhPDwcLBYLjY2NKC4uvubrdDodDh48iMTERAQGBkIkEkEqlSInJwd79+6Fn58fuFyuvRwFAgFkMhl8fX2h0WhgMBgc8nnalpn28vLCkSNHYLFYHDogtLy8HLW1tfDw8EBeXp5DVmITCARIS0tDYGAgenp6UFZWhvb29mu+tqqqCo2NjUhISLhmotLV1YXXXnsNGRkZyMrKcspmULYEc8mSJSgqKkJjY+O4J5JXMpvNKCwsRHNzMxYsWIDQ0FCH1KnBwcFISEiAQqFAW1sbCgsLYTKZrvnaw4cPQ6FQICIi4qpxDFKpFHK5HF5eXlc9pFKpwwYj8/l8BAQEYN68edi9e7fTB2e7gp/1LbNYLMjPz4dMJkNsbCy8vb3HKq4fJBQK4e/vj4yMDBiNRhw7dgwajeaarz127BiUSiViYmLA4/HA4XAQExODmJiYUQMObfh8PgghEAqFDhs8xGKxIJVKsWjRIjQ2NqKhocGhrQOdnZ0oKyuDr68vkpKSHLbbmbu7O5KSkhAQEIDe3l7k5+df83U6nQ7ffvst5s+fD6lUak/cfHx8kJWVddVUK4ZhYDQaMTIyAl9fXwiFQodUqGw2G4mJiYiIiEBDQwMaGxvH/ZhXunDhAgwGA0JDQx02TZXD4cDT0xOZmZkAgOLiYtTX11/ztVVVVejo6EBWVtZVU457e3tx8eJFXLx4EXfddRd8fHycMvvBdve7ePFi+yZVvb29Dju+0WjEyZMnoVAoEB8fP66tAlcSiUQIDg5Gamoq9Ho9jh49etWgQptDhw4hMjISYWFhE3ajORaLBS8vL+Tm5qKhoQENDQ10ZsEN/Kwa0mq14vTp04iNjYW/v/81L67jRS6X25v9jx49ioGBgVF3f4QQDA0N4dKlSz+pcmxvb4fBYEBkZCRCQ0MdNo1HJBJh5syZAC7f4Q0PDzvkuMDlO7La2lokJibCy8vLofOr09LSEB0djcHBQRw/ftw+s8PGZDKhr68PhYWFWLBgwQ8maFarFSMjI2hra8PFixcxMjKCBQsWwNPT02EJTnh4OCIiImAwGFBSUuKQY9oUFhbaW8EcdREBLle8S5YsgVAoRHFxMWpqamCxWEa9RqPRoK6uDsPDw8jOzh71N5PJhMrKShw/fhx+fn5YsmSJ0y8yGRkZEIvFaG9vR3Nzs8OOazKZcPr0aSQmJkKpVDp0NoOfnx/mzZsHQggOHz4MrVZ7VZ06ODiIwsJCxMfHIzg4+Kr3sLUy5ufn4/Dhwzh69CjOnz+Pjo4Oh1+MpVIp0tPTAQClpaXQ6XQOPb6ruelanxACi8WC4uJipKSkQCKRjGVcNySXy5GbmwuhUIiCggJ0dHSMymTJd/t9a7VaREVF3XDPa1tf3f79+8EwDPLy8jBr1qzxPg07LpcLHx8fhISEoLq62mHJgK0/vqOjAxkZGQ455pVSU1MRFxcHvV6PgoIC9Pf3j0oGBgcHUVFRAZPJhJkzZ153u9mRkRG0t7ejuLgYO3fuxOuvv47w8HD84Q9/cOimSu7u7vD394eXl5fDkgHb2J2qqip4eXkhNDTUIce1YbPZWLRoETw8PFBTU4OqqioMDQ2Nek1tbS06OzshlUqRkpIy6m89PT04deoUioqK8OSTTzr0puJaWCwWfHx8EBwcjMHBQYclA4QQGI1GlJSUID093eHTGpVKJebOnQuBQIAzZ86gu7t7VFeB1WpFcXExdDrddbt6Tp06hVdffRWPPfYYHnzwQTz44IN4+umnsW3bNrS1tTk0IeDz+fD19UVISAjKy8tpMnADN50MWCwWqFQqtLS0ICkpyeHJgEAgQGBgIObOnQuz2YwjR47Ym2VtlePWrVsxf/58BAYG/uCdoS0R6OnpwQsvvICcnBysXr0aiYmJjjodAJcr1fT0dFRWVl5VmY4XrVaL7u5uDA0NXVVJO4KXlxcSEhKQlJQEjUaDXbt22ftoCSFoaWnB8ePHsXr16h9ccOWtt97CnDlzkJ2djRdffBHe3t744IMPEBcX5/C7TC8vL0RHR6OwsNBh/ZRqtRqtra32ys+RWCwW/P39kZmZCXd3d1RVVY3q8iGE4ODBgxCLxcjMzBzV/E8IwUcffYSysjKsXLkSs2fPnjCL6iQkJECv16OpqckhxzObzfY6NTU11eHJgK2rIDs7G0ajEQcOHEBnZyeA/+ya+Pnnn2PZsmXw8fG5qk5lsVjQaDS48847sWPHDly6dAm7d+9GSEgIfv/73+P3v/89Tpw44dC+ey6Xi4yMDJSUlNBk4AZuOhkwmUxob28HIQQRERFOyeYFAgHuuusucLlc7N27F7W1tQD+s+/39u3bsWzZMgQFBf3g+5jNZtTW1mL16tXIzMzEiy++6JQLI4vFQlRUFLq7ux02ZqC/vx9qtdq+cJMzTJs2DYsWLYLJZMKWLVvsI3/NZjMaGxtx6tQp3HXXXT94kXj88cdRUVGBhoYGvPvuu/YLz4svvojBwUEHncllUqkU/v7+aG1tddgx29raYDaboVQq4ePj47DjXun2229HYGAgKioqcODAAQCXf4sGgwGHDh2Cp6cncnJyRv0/27dvx7lz5xAVFYVf/epXToj6+oKCgmCxWNDf3++Q4+n1enR0dIAQYl922NGkUik2btwIFouFHTt2oK2tDcDlctRoNNi+fTvWrFlz1UwPNpuNb7/9Fh9//DHWrFmD0NBQeHp6IiEhAe+//z6ys7Nx5MgR7NmzB3V1dQ47Hw6Hg8jISLS3t9MxAzdw0yN0LBYLBgYGAACenp5OGezD5/ORl5cHDw8PNDQ0oKamBj09PXBzc8OxY8fg5+eHmJiYH2y1MJlMKCgowOuvv47g4GC8+OKL8PPzc9q65DKZbNRqeuNtZGQEOp0OXC7Xof3MVwoLC8OsWbMgFApRUlKChoYGREdHo7a2FvX19QgMDLzhyow8Hg9cLhdCoRAKhQLh4eHo6urCG2+8gYSEBGRnZztsqhqfz4dEInFoEqJWq2G1WuHm5gaxWOyw415pzpw5CA4ORm1tLcrLy9HU1ITQ0FAcP34cAoEAERER9mmhhBB0d3fj3//+NzIzM3HrrbfCzc3NKXFfj7u7u30ciiOYTCb7d8aR41yuJBKJkJeXB3d3d9TU1KCmpgYJCQngcDg4efIk/P39ERsbe9XNn21a5vexWCzw+Xzk5uairq4O9fX1KC0tddiqgCwWCzKZDENDQw6dFeKKbvoKblsmFrj8BXLGxZPFYkGhUGDGjBk4ceIEysvLUVFRgWnTpuHbb79FTk4OPDw8rvujYhgGp06dwoEDB8AwDH71q1/ZN+VxRlMli8WCWCx22FQ44HIFZDabwWKxnLL0KnD5+xMYGIi0tDScOHECx48fh1KpRGVlJTo7OzF79uwf1fLEYrHA4/HA4/EQEhKCrKwsHD9+HBcuXEBcXJzDkgHbcsiObJY0GAwghIDP5ztt8J1cLkdiYiIqKirQ09OD/Px8hIaGjhp9bptaRghBUVER6urq7OsPXLlMbWNjI3p7e6HX6/Hee+/h6NGjYLFYeO655+Dt7e2Qmw+RSGTvx3eE79epzqiDOBwOFAoFZs6cifz8fBQXFyMpKQk+Pj44evQo5s+fDzc3t59c3wcGBkIoFGJ4eBgqlWqcor8ai8WCm5sb9Hq90/eamOhu+grOYrHsXwir1eqUOZwsFgscDgd5eXmQSqWorKxEYWEh+vv7cfbsWSxatOi6A86Ay6P2jx8/jq6uLixatAjz58+3JwIXLlzA+fPnHd7EzDCMQysB21Qq27Gdgc1mw8vLC/PnzwdweepSd3e3fSDlnDlzfvJ7crlc+45lzc3N1516Oh7Id2vLOzJBth2LYRinzafmcDhISUlBdHQ0BgYGcOjQIWi1Wpw5cwbTpk27avS5QCDAsmXLEBkZCTabDa1Wa3/YKm+r1QqDwWB/3pHfUduxHFWOV9apzvotslgscLlcLFy4EEKhEEVFRSgtLUVPTw8uXryIxYsX/+xEzNHfT4ZhJsQOlBPdTZcqh8OxLwqi0Wjg7e3tlGYtAFiwYAHef/99NDQ04OzZswgJCUF3d7d9PvO1qNVqbN26FS0tLUhLS8N99903Kv6PP/4YVqsVjzzyiMOaz23TISUSicO6XcRiMYRCIaxWKzQajdOamGUyGXJzc/GXv/wFp0+fRlFRERoaGsDhcOzTg66k1+uh1WpBCLluH7ltJLTFYnFo5Wo2mzEyMjKuG7J8n239Bb1eD4PB8INJ8HhKSUlBbGwsjh49ipMnT6KkpASdnZ2Ij48ftXkTm81GXl4e8vLyrvk+W7duxZ/+9CeEh4fjvvvuwx133OGoU7DTarX27XEdgcvl2uvU4eFhe5k6mm12yGuvvYaqqiqcO3cOHA4H/f39yM7OvqpuYhgGGo0Gw8PDV22KZbvwd3Z2wmg02hclchSGYTA4OAipVOq065OruOlvmm2xEeDyhfX784odxbb0ZGxsLLhcLk6cOIF//etfWLhwITw8PK76MdlmGrz11ls4f/48FixYgAcffBDA5YuH7eGszFylUkEqlTqsqdfWx2yxWKBWqx1yzGuRSCRITEy031X+/e9/h0qlQlpa2jVXojt//jyef/55PPPMM/aWKduDYRjodDqcOHECABAXF+fQ6YVGoxEajcahx5TJZOBwOPY7aGcJCwuzTzvr6OjAb3/7W2RlZcHf399pCcrNGhwcBIfDcdhYBh6PBw8PDwD/GQPiDCwWC0lJSYiJiQEhBPv27cPHH3+M3NxcuLu7X9VyOTIygq1bt+K2225DZ2envXXKlghYLBYcPHgQAwMDiIyMRHJyssPOhRAClUoFDw8PuoX3Ddx0MiAUChEeHg6BQIDy8nKHDbK5nltuuQXR0dFQq9VoaWmxj4j9PtuI9RdeeAGHDx/GAw88AE9PT4hEolGPt99+26F9W8DlLLa4uBgREREOW4pVqVRCqVTCarWitLTUIce8HtvsEB6Ph8rKSoSGhmLu3LnXfb1KpcLnn3+OF154AXV1ddBqtejv78eJEyfwv//7v/jiiy+QnJyMX/ziF/YuA0dQq9VoaGi4ajvm8RQREQE3Nze0t7dfdzlgR0lISMCSJUtgtVpx8eJFrFu3zuH7DIyFmpoa8Pl8BAYGOuR4YrEYYWFh9oG0zh79vnr1agQHB6Onpwf9/f3YsGHDD76+pKQEf/zjH3HgwAH09PRAo9GgvLwc999/P86ePYu8vDysXLnSoVsK29ZGuN6Ks9R//KwxAyKRCNOmTUNZWZlT70aAy10FkZGRcHNzQ3BwMLKysq75OrPZjH379tlH69vuJL//uDKzdQRbHJcuXUJsbKzDmphtix0plUpcunTJIce8Hj6fj9tvvx0CgQDe3t5ISkpCbGzsNV+bkpKCp556Cn/84x9x8eJF3HPPPcjIyEBmZiZ+85vfoKamBr/73e+wbds2hISEOKyJkBBiTwZSU1MdNv5DIBAgOjoaKpXKoVMaryU6Oho5OTngcrnw8/NDVlbWj1qHpL29HU8//TRCQkLw61//Gk1NTThx4gR+/etfIzo6Gvfcc49DWiBtv/2qqiqIRCKHJZJsNhtisRjx8fG4dOnSdZcDdpSlS5ciMDAQUqkUYWFhmD179jVfJxaLsXr1arzxxhtgsVh45ZVXsHTpUqSlpWHdunXo6urCX/7yF7zwwguYO3euw34ThBCYzWYUFRUhKSnJaV2gruKm201sg/fS0tJw4cIFDA0NgRDitAVDfHx88Nvf/hbr1q2Dp6fndQteKBTi8ccfx4YNG254sQ8ICLjmkpvjwbYka39/PxITE+3NhePNttpaUFAQCgoK7INtnFGObDYbgYGB+OSTT8DlcpGQkHDdjU0kEgmio6Ph4eGBefPmQavV2jcj4fF4cHNzg1KptCcCjjqfzs5ONDY2wmAwIDU11SHHtJ1bYmIizp8/j/r6eqcOmpJKpZgzZw62bdtm3zTqx8Qik8mwfv36a1502Gw2vL29HXZOVVVV6OnpQXJyMsLDwx1yTNs0vLS0NJw9exYjIyNOrVP9/PzwP//zP1CpVFAoFNed4cBmsyGTybBixQqkp6djeHgYer0eFosFbDYbHh4eCAkJgVKpdGhXkU6nQ3V1NVQqFVJSUmgycAM/qxOFy+Vi3rx5+Prrr9Hc3GxfaMIZbLunpaWl/eDruFyufVOViUSn0+HUqVOQyWSIjo526JzrgIAAJCQk4OjRo2htbUVwcLBTBtvYpjeuXLnyhq9ls9lwc3NDeHi4wyrrH6Ourg6NjY3w9va+4doIY23GjBkoKChAY2Mjurq67HP6Hc3WInDbbbf9pP/Pzc3tR/2GHeHUqVNgs9kICQkZNfBxvAkEAsydOxc7duxAS0sLvL29Hb6665Wx/Ji60nZjGBAQ4LTv3LUMDQ3h7NmzkMvliImJcdrUaVfxs9JsDoeDefPmgc1m49KlS07vq3RVVqsVAwMDOHjwIFJTU+1zch3F398fKSkpMJlMOHHihNMGg7o6s9mMkpIStLW1ITk5GX5+fg69q8vIyIBCoUBHRwcKCwsddtzJxLbs7sGDBxEYGHjNbXrHky0ZIITg/Pnz6OnpcdixJxOr1Yre3l4cO3YMqamp8Pf3d9j2ya7qZyUDbDYbAQEBmDFjBk6fPo2ysjK6ytNN0Ol0aGhowMmTJ7FmzRqHZ7ASiQRhYWFISUnBli1boNPp6N7fN6G7uxuFhYUYGRnB4sWLHX58pVKJpKQk+7gYi8VCy/EnYhgG7e3tOH78OGbNmoWIiAiHHt92hz1z5kx8++23qK+vp3XqTRgeHkZdXR3OnTuHNWvW0JkEP8KYdMA9+eST6O7uxtGjR50+It0VlZSU4L333oNSqcSGDRucMurVz88PTzzxBI4ePYojR444fLGlyeDdd99FfX09kpKSsGLFCqfEcNtttyEpKQlHjhyxT62kfjydTofnn38eHh4eWLFixY/e+nwssVgsPPPMM6irq8PRo0dRXV3t8Bhc3ZkzZ/DZZ58hICAAd955J00GfoQxSQZmzJiBhQsXoqamBps3b3b6lBhX0tTUhGPHjuHChQv4wx/+4LS52BKJBJmZmVi8eDFeeukl1NXV0e6CH4kQgsLCQnz11VeIjY3F6tWrnbYkcHR0NObNm4fQ0FD8+c9/tg+qpG5seHgY586dw5dffoknn3wSgYGBThuEOWvWLCxcuBCnT5/Gzp07aZ36E9TV1eHw4cOor6/Hk08+6XLrWzjLmHzTeTweNm7ciOjoaFy4cAFbtmwZi7ed9AwGA3bt2oX8/HykpqZi+fLlo5YHdiTbvgi/+93voFKpsHXrVqdPNXQFhBDo9Xq88MILcHd3R05ODlJSUpw2Atw2w+fOO+9EU1MT/v3vfzt9iporMJvNqKmpwauvvorExEQsX74cHh4eTvst8ng8/Nd//ReUSiVOnTqFbdu2OTwOV6TX67FlyxaUlpYiPT0dixcvdlqd6mrGLO2NjY3F3Llz4evri23btqGsrIzekVyHbU2BAwcOID8/H0KhEOvXr4e3t7dT47It/bto0SJcvHgRR48eRXNzs1Njmshs2/N++eWXKCkpwbJly5CRkeHQZYivxdvbGzNnzkROTg4+//xzXLp0yenrgExkhBBUVlZi7969aGhowIMPPgh/f3+nNy1PmzYNOTk5EAqF2LlzJ8rLy2mdeh22OvXrr7/GmTNn4OPjg9WrVzu9TnUlY5YMuLm5ISsrC3PmzEF7ezu2bt2Kvr4+OvjlOqqqqvD5559Dq9Vi9uzZEyKDZbFYcHd3xy9+8QsIhUIUFBTg8OHD9q2qqdFGRkZQXFyMTZs2ITIyErfccgvCw8OdfhfC5/MRHByMjRs3oq+vDzt37kRDQ4NDd1F0JS0tLTh06BBOnDiBxMRE+4AzZ5ejRCLBggULkJqaiqamJmzfvh0qlYruvncNtoRuy5YtYLFYmDNnDnJycpxehq5kTDvEIiIisGTJEixatAhvvvkmjh07RveRvoIte9VoNPjnP/+JwsJC5OTk4I477nD63eSVsrKysHbtWgwPD+Pjjz/GmTNnYDKZ6F3Jd2zb2lZXV+P1119HbW0tnnnmGURFRU2Y/kmpVIr58+fjrrvuwieffIK9e/eisbHRvvLmVGdbZVCr1WLr1q3YvXs3uFwufv/730Mmk02Yi0hcXByWL1+OWbNm4c0338Tx48cxMjJCE4LvEEJgtVoxNDSEV155BaWlpbjttttwyy23OGxJ90mDjDGGYUhvby+58847ibu7O9myZQvp6uoiDMOM9aFcCsMwhGEYMjg4SJ544gkiEAjIa6+9Rpqbm50d2jVZrVby+eefk7y8PBISEkKOHDlCrFYrLUeGIVarlRw4cICsXbuWyOVysmvXLmI2m50d2lVssT788MMkNDSUPPzww+TSpUu0DL/7LVqtVvLcc8+R8PBwsm7dOnLy5Elnh3ZNDMOQpqYmsn79eiKVSsnOnTuJSqWi5fhdOXZ1dZHHHnuMcLlc8sEHH5Curi5nh+aSxiUZsFqtRKPRkPXr1xNfX1/y5JNPkosXL471oVyKxWIhRUVF5I477iBisZi8++67pL+/n1itVmeHdk0MwxCj0UjOnDlDVqxYQdzd3cmnn35KhoaGnB2aUxmNRvLXv/6VZGRkkJSUFPL5558Ti8UyIStmW2U5MjJC/vSnP5Hk5GQye/ZssmfPHmeH5lQMwxCtVkvuvfdeIpPJyNNPP00uXrxILBaLs0O7Jludqlarydq1a4mXlxf585//TMrLy50dmlOZzWZy/Phxsnr1aiKVSsmmTZvI8PDwhPwtugIWIWPf9ku+a4Jra2vDv/71L5w6dQq+vr644447sH79eoeuFT8RqFQqfP3119i2bRsaGhrw1FNPYdWqVfD09JzQe2yT70bK19fX45VXXkF+fj7uuusu3HHHHYiNjZ3QsY81Qgi6urrw/PPP49SpU0hKSsIdd9yBefPmOWwfiZtFCEFPTw/27duHr776Cg0NDfjlL3+Jhx9+GAKBYEr9FnU6HWpqavDyyy/jxIkTePLJJ7F06VKEhIRM6F3tyHddjG1tbfj73/+OM2fOIDY2FmvXrsWtt97q9MGOjtbX14cvvvgCe/bsQV9fHx599FGsXr36mtvWUz/OuCQDAOz9yyUlJdi7dy8uXLgAnU6HvLw83HfffVAoFFOi0EpKSrBz505cuHABhBAsWrQI69atg7+/v0tUwuS75VmLiorw3nvvoa6uDtOmTUNeXh7mz58PuVzu7BDHnV6vR2lpKd577z2UlpZi9uzZWLRoEWbOnOkyW/PakvOCggLs2bMHdXV1uOWWW3DHHXcgODh4Sqzb3tzcjNOnT+Obb75BTU0NVq9ejXXr1jl8+e+bZatTCwsLsWvXLhQXF4PFYiE3NxcbN26Et7e3S9QpPwchBMXFxfZZMm5ubli4cCFuu+02l6lTJ6pxSydthTJ9+nT7zmUHDx7EV199BYFAgDlz5iAqKgoSiWTSJQVWqxUjIyMoLCzEvn37cPHiRXh5eSEnJwdr1qyBn5+fs0P80VgsFgQCAWbNmgWz2YxPPvkE1dXVGBwcxMDAAGbNmoW4uDin7XQ4ngwGA7q6ulBaWopDhw7h4sWLmDdvHu644w5MmzZtQg36vBEWi4Xg4GBIJBJIpVJs2rQJX3/9NRiGwaxZsxAfHw9/f/9J19pDCMHIyAjKy8tx+vRpnDt3Dh0dHcjLy8Ndd93lUuds+32lp6eDx+PBw8MD+fn52LVrl32fmOjo6OvuLujKLBYLNBoNiouLsWfPHpw/fx4hISHIy8vDsmXLoFQqnR2iyxu3loHvGxoaQklJCf72t7+hpKQEt956K9asWYOYmBh4enpOii8wwzAwGAxQqVSorq7GK6+8gurqauTl5dmblF19s4zW1lZ8+OGH+PbbbzE8PIylS5fiwQcfhK+vLyQSict3AdmaY4eGhtDa2ooTJ05g165daG5uxl133YXHH398wnfv3IjFYkFzczOefvpplJWVITExEUuWLMHChQuhUCjso7BdvRwtFgsGBwdRWVmJ9957DyUlJVAoFLjtttvw0EMPuXwXiVqtRkFBAV5//XWUl5dj1apV2LBhA8LCwuDh4QGhUOjS5wdcvrHS6/Xo7+9HRUUFXnvtNVRVVWHlypX4xS9+YU+MqDHgyAEKtsFML7/8MvH39yehoaHkgQceIAcOHCB6vd4+EMuVBoDY4rVYLESlUpEDBw6Q++67j0ilUpKUlET27t1L1Gq1s8McU2azmRQVFZHf/e53RCaTkaioKPLmm2+S5uZmYjKZXHLWga0czWYz6ejoIC+88AJJTU0lfn5+ZPHixSQ/P9/lzumHMAxDTCYT2bRpE5k3bx5RKpVk9uzZZPPmzS77WyTkP4PtRkZGSG1tLXnqqaeIh4cHiY2NJX/9619JdXW1s0McU1arlQwODpKXX36ZKBQKEhYWRh577DFy/PhxYjAYXLIcr6xT+/r6yI4dO8iGDRuIu7s7SUpKIocOHSIajcbZYU46Dk8GbD/W1tZW8txzz5Hp06cTDw8Pkp6eTj766COi1Won7Aj7a2EYhrS2tpIXXniBpKWlEZlMRqZNm0b+9a9/Eb1e75IXxhuxlaPBYCD19fXk7rvvJlKplISEhJAHH3yQ7N+/n+j1emeH+ZPodDpSVVVFnn76aSKTyYi3tze5//77yf79+4nBYHC5CvVGrvwt9vX1kZ07d5Jbb72V8Pl8EhcXR958803S1NRETCaTs0P9SXp6esi2bdvIhg0biIeHB/H19SV/+9vfSEdHBzGbzZOqDAkZXY4tLS3kqaeeIrGxsUQul5Ps7GyyefNmotPpXOq8r7w+xMXFEblcTmbMmEHeeustotfrJ91vcaJwWDfB91ksFoyMjKCzsxNFRUXYtWsXTp8+DYVCgcWLFyMvLw/Tp0+fkH1BVqsVfX19uHDhAnbt2oUjR46Ay+UiKysLCxcuxJw5c+Dl5QWJRALAtZtbfwi5YsGPmpoa7Nq1C6dOnUJHRwd8fX2xYsUKrFmzBhERERNmMZ4rmc1mlJSU4MSJE8jPz8elS5fA5/Nxxx13YNWqVQgODoZUKp0Uza0/xGq1wmg0YnBwEDU1NXjvvfdw6tQpiMViJCUlITc3FwsXLnT4dr4/BvlugOupU6ewY8cOnD59GsPDwwgICMCyZcuwdu1a+Pr6ws3NbVKOa7Gx/RY1Gg3a29tRUFCAvXv34vz581AoFLjllluwePFiTJs2bUIOerVarejs7MS5c+ewd+9eHD16FDweDwsWLMCiRYuQkZEBuVw+6etUZ3JaMmBjMpkwMDCA5uZmVFdX4+TJk2hoaAAhBF5eXggPD0dqaioyMjIQHBwMHo/n8C8C+W4N+srKSpSWlqKyshL19fXo7e2FRCJBUlISMjIyEBERgcDAQCgUCpfuU74ZIyMjaGtrQ1NTE2pqanDp0iXU1dVBJBIhPDwc8fHxiI+PR2xsrH03OEeXo8ViwfDwMGpqanDhwgUUFhaira0NDMNAoVAgNjYWM2fORExMDIKCgiAQCCbd4NYfwjAMRkZGUFdXh6qqKhQVFaG+vh5qtRoikQjR0dGYOXMmkpOTERwcDHd3d6d8PgaDAa2traipqUFFRQVKS0vR3NwMiUSCyMhIJCQkIC4uDqGhoQgODnb5cSw/ldFohEqlQnNzM2pra5Gfn4/6+npwOBz4+PggIiICycnJSEtLQ2ho6Lh9PuS78Te2ZdavPAb5btpyRUUFiouLUV5ejqamJqjVanudOnPmTERGRiIgIAAymWzK1amO5vRkwIZhGGi1Wly4cAFFRUWoq6tDX18fjEYjxGIxgoODERISAqVSCYVCAS8vL8jlcsjlcri5uY3Jl5l8tz7C8PAwhoaGMDAwgP7+fvT09KCjowMNDQ1Qq9XQ6/Xgcrnw8/NDYmIiZs2ahZiYGIhEoil18bgWo9GIvr4+lJWV4cKFC6ioqIBGowGPx4Onpyf8/PwQFBSEgIAAKJVKyOVyeHp6QiqVjtk87ytbLNRqNXp7e9HX14e+vj50d3ejpaUF/f39MBqN9oQzLi4OiYmJ9vUTptLF41q0Wi2qqqpQUVGBqqoqNDY2QqPRwM3NDf7+/vD394evry98fHzs/8pkMojF4jGb884wDPR6PTQaDQYHB9HT04POzk50dXWhvb0dvb29GB4ehsVigZ+fH5KTk5GcnIzo6Gj4+PhM+YuH1Wq116kXL15EbW0tVCoVLBYLxGIxgoKCEBYWBqVSCW9vb8jlcshkMshksjGpU00mE3p7e2EwGODp6QmNRgO1Wg2VSoXe3l50dnaivr4eKpUKBoMBQqEQfn5+mDZtGmbNmoXY2FiXH+TpSiZMMnAl2+IalZWVKCwsxPnz59HU1ARCCJRKJQICAuDv74/AwECEhobC19cXQqEQXC4XPB4PXC4XXC4XHA7Hfgdqu0gzDGO/WDAMA4vFArPZbP93ZGQEHR0d6OzsREdHBzo6OtDW1obu7m64ubkhOjoaycnJSElJwfTp0+Hr6+vkT2tisiVWZWVlOHfunD3B6+3tBQCEhYUhJCQEAQEB9sTAy8sLAoEAPB7PXo4cDsd+cbaVpe2Ow/av1WqFyWSCxWKBxWKB0Wi0l2NTUxNaWlrsFw+NRgOJRILk5GRkZ2djxowZCAoKsjc/UqMRQqDRaFBdXY3Tp0/j5MmTaGlpgdFohEQiQUBAAIKDg+3l6e3tDTc3N3sZ8vl8ezleWYYsFmtUGdrK0Ww2w2w2w2QyQa/XQ6VSobu7G+3t7WhpaUFjYyN6enrA5XKhVCoRHx+PmTNn2ndMneoJwPUwDIOmpiaUl5ejqKgIRUVFaG5uBiHE/hv09/e3l6etTrX9Dnk8nv23yGazR7Xsfb9OtdWnw8PDKC0tRX9/PwICAuw3VbZHT08P3NzcEB8fj5SUFKSkpGDatGl0p0EnmZDJwPcxDIPq6mqcP3/e3qRkyygZhoG7uzsCAwPtrQUKhQIymQxSqRR8Pt/+YLFY0Ov19vEKOp0OarUaarUaAwMD6O7uRlNTE6xWK7hcLuRyOSIiIpCamopZs2bZF5lx9emBzjI4OIiGhgZcvHgRZ8+eRWFhIbq7u6HX68Fms+Hu7o7Q0FAoFAr4+PjYWwzEYjF4PB5EIhH4fD4MBoO9wtHpdNBqteju7rbfdfT09KC7uxsMw4DH4yE8PByJiYlITExEUlISpk+fDoVCQe84blJDQwMqKipQVlaG0tJSXLp0CV1dXWAYBmKxGAqFAr6+vvDy8rIneW5ubvZEz/bvyMiIfeqYXq+HVqtFb28vVCqVPRm37bQoEokQERGBzMxMpKWlITk5GUFBQS611sNEYrFYUFtbi7Nnz6KoqAhlZWVobm7GwMAALBYLeDweoqOj4e3tDYVCMaoFj8/nQyAQgM/n25v7bWurjIyMQKVS2VvkKioq0N/fD4FAAIFAAB8fH0RGRmL69OnIyMjA7NmzoVAoptwKihORSyQDwH9W37KxWCxQq9WorKxEVVUVWlpa0NfXB5VKhb6+PvT390Oj0cBoNMJgMNh33bNdWCQSCSQSCeRyOby8vKBQKODn54eYmBhER0cjLCwMMpnsml9SehG5Odf6qmk0GnR0dKCxsRENDQ1obGxEb28venp6oFKpMDw8DJ1OB6PRCJ1OB5PJBKFQCD6fDx6PBzc3N7i7u8PPzw8KhQLe3t7w8/NDaGgoYmJiEBcXZ08Er0TL8OZdqxzVajWqqqrQ0NCAtrY2dHV1ob+/H11dXfYWGZPJZP89ms1mewuCSCSCm5sbpFKpvcshICAAoaGhCAsLs/f9XysJp+V4875fjiaTCd3d3di/fz8eeeQRrF69GgKBAENDQ+jv74darbbXqXq9HiaTCSwWCyKRyF6nSqVSe30KAAUFBejq6sKHH36IRYsWXbf7hpaj87lMMvB9tmZoq9Vqb566svn4yoft9cB/vnRXDmq5siuBzWaP6l6gX9LxdWVTv625+PtlaXud7d8ry9D275VlyGKx7GVoq3hoOY6fK3+L1yvDG5XjtX6PVzZJT+aZABMF+W61xuPHj2PlypU4d+4coqKiwOFwfnKdarFYUFhYiGXLlsFiseCBBx7A73//e0RGRtJynKBctm3myoqDrkDlumyVPu3rdV1X/hYp12W7SA8PD4PH48HLy+umZ4x0dHSgubkZFosFAHDgwAHceeedCA4OnpDTjCmA/nopiqIoAJdnIAwMDEAikfysady9vb2oqqqyJ/m9vb0oLi5GR0fHWIZLjSGaDFAURVEALg/WHhwctM/r/znJQEVFhf3/t1qtOHnyJGpra6855oRyPpoMUBRFUQBGJwM32+3DMAw6OztRUlJi7yZgGAYnTpxAWVkZDAbDWIZMjRGaDFAURVEALt/Bq1QqKBSKm04GVCoV2tvb0dPTM+r5gYEBFBcXo7CwcCxCpcYYTQYoiqIoAJeTgf7+fnh7e9/0oN7y8nLU1NRc1cXAZrNx5swZ7N69eyxCpcYYTQYoiqIoAP9pGZDL5TfdMlBdXY3GxsarkgGGYdDR0YHi4mLU1NSMRbjUGKLJAEVRFAXg8gVbo9HA3d39pgYPMgyD+vp6+1LH32exWNDZ2YnDhw+PRbjUGKLJAEVRFAXgPwsP2bZ8/qkGBwfR3t6O/v7+684a6O3txeHDh6HX6+nMggmEJgMURVEUgP9sLSwSiW6qZaC+vh59fX0wm83XfX+VSoXz58+jpaXl54ZLjSGaDFAURVH25aN/TjJw8eJFqNXqG7Yq6HQ6fPHFF7BarbR1YIKgyQBFURQF4HKfv06ng0Qiualk4OTJk+js7ATDMNd9DSEEQ0NDeOONN2hXwQRCkwGKoigKDMPAaDTCarX+5JYBW/dCWVkZ1Gr1dV/H4XDA4/HA4XAwODiIb775BiMjI2MRPvUzuexGRRRFUdTYsVqt9tUBb6aboLy8HMPDw7BareBwOODz+RCJRPaNyAIDA+Hp6QmxWAw3NzeIxeKbboGgxh5NBiiKoihYrVYYjUYAN5cM8Pl8bNiwAXq9Hnw+H3w+H1wuFwUFBeju7saqVasQEREBgUAAkUgEkUgEf39/8Pn88Tgd6ieiyQBFURRlTwZYLBZEItFPnloYERGBP/zhDxCJRODz+WCz2TAajXjuuedw/PhxLFmyBKmpqeMUPfVz0WSAoiiKgsVigV6vB/DTWwZYLBYkEsk1n+fxeDCbzT84qJByPjqAkKIoioLVarUnA2KxeMz68m3JAJ01MLHRZICiKIqC1WqFyWQCAAgEgjFLBvh8Pk0GXABNBiiKoij7okMAbnqTomvh8XiwWCy0m2CCo8kARVEUBQD2C/bNbl/8fbYxAxaLhbYMTHA0GaAoiqJACLFfsMeyZYDL5dJkwAXQZICiKIq6qptgLAcQ0mRg4qPJAEVRFAVCCKxWK4CxbRmgAwhdA00GKIqiKACwX7DHaswAQFsGXAVNBiiKoqhx6yZgGIbuP+ACaDJAURRFjUoGxrJlgGGYMe12oMYHLSGKoihqVDIwlnfytpYB2jowsdFkgKIoigLwnwv3WN7J05YB10BLiKIoigJwuUXgyvUGxgIhZEzHIFDjgyYDFEVRFNhsNng8HgDAZDKNWUJABxC6BpoMUBRFUaOSAbPZPGbva7VaweFwaEIwwdFkgKIoigKbzQaXywWAMV0kiLYMuAaaDFAURVFgsVijkoGxQgihswlcAE0GKIqiqFEtA2O5YiCdTeAaaAlRFEVR49IyQAiBxWKhYwZcAE0GKIqiqHGbTaDT6SASicZ0VUNq7NFkgKIoirpqNsFYJAOEEIyMjEAkEtGuggmO6+wAKIqiKMchhMBsNqO2thYajQZarRYjIyNQq9WorKwEwzB46623IBQKodPpoNVqYTAY4Obmho8++ugnN/nr9XqaDLgAmgxQFEVNMSaTCVu2bEFjYyOMRiPMZjMMBgMGBgbAYrFw+PBhWK1WGI1GmEwmcLlcJCQk3FS/v8FggEAgoN0EExxNBiiKoqYQ25LD9fX12LNnD6xW61XLBTc1NY3qJvD19UVcXNxPXlaYEAK9Xg+BQEBbBiY4WjoURVFTDJ/Pxx133AGBQABCCKxWKywWCywWC6xW66hEgMViwd3dHTNnzrypY+l0OgiFQpoMTHC0dCiKoqYYPp+PW2+9FV5eXjdsvieEwM3NDVlZWT/5OLaWATpmYOKjpUNRFDUF8fl8PPDAA/D19f3Bpn+xWIyAgACEhYXd1JgB22wCOmZgYqPJAEVR1BRju6ivX78eXl5e173Is9lshIaGIi0t7abu7Akh9nUGaMvAxEZLh6IoaooKCgpCSkoKfH19r3mxJoRAqVQiISHhpo8xMjICoVBIWwYmOJoMUBRFTUEsFgsikQhz585FaGjoNV9DCIGPjw9iYmJu6hiEEAwPD0MikdBkYIKjyQBFUdQUlpOTg4iIiGterPl8Pvz8/BAREfGT35cQAkIIBgcH4eHhYd/3gJqYaDJAURQ1hUVERCApKQmhoaFXdRUEBQUhODgYEonkpt7bYrFAo9HA09PTvtQxNTHRZICiKGqKy8nJwZIlS8AwjP05Ho+HtLS0m+4isFgs6O/vByEEXl5eNBmY4GgyQFEUNcUlJiZi9uzZkMlk9ufMZjPi4uIQHh5+U+9psVigVqsBADKZjHYTTHA0GaAoipriBAIBwsPDkZeXZ+8q4PF4CA8Ph7+//029p9VqxeDgIADA09OTJgMTHE0GKIqipjgWi4XAwEAsXLjQngwEBQVBqVTCzc3tpt7TYrFgaGgILBYLUqmUJgMTHC0diqIoCt7e3pg5cyYUCgW6u7uRmJgImUwGQoh9Z0PbvgUMw9j3L7BtXsRms8HhcMDj8cDhcGC1WjE0NAQ+n08XHXIBNBmgKIqawmwXdxaLBblcjkWLFmHLli1ISEgAl8tFV1cXBgYGoFarMTw8DIZhoNPpYDabwWKxIBQKwefzIRQKIZVKIZfL4eHhAZ1Oh97eXnh6esJiscBkMoHD4diTh5tZ2pgaPyxy5fZUFEVR1JRiMBjQ1NSEuro61NTUoKCgADt37oRcLodOp4PRaMRPvUxwOByIRCLI5XLIZDLk5uYiOjoaUVFRiIyMRHBwME0GJhiaDFAURU0RthUBy8vLcfz4cZw5cwYVFRUYGhoCAHh4eCAkJAQdHR3YsGEDAgICIJfL7Q9PT0+w2WyIRCLweDx7F4LJZILBYMDw8DBUKhXUajXUajV6enpQX1+PpqYmtLa2QqfTgcfjwcfHB+np6cjKysK8efMQFBR002MTqLFBkwGKoqhJrrKyEufPn0dRURGqq6vR3d0NsViMsLAwhISEICIiAkFBQfDy8oJQKMTg4CBCQkIgFArB4/HA5XLtD9v4ANudvW38AMMwsFgssFgsMJvN9q4BvV4PvV4PnU6Hnp4etLS0oLGxEc3NzWhqagKPx0NISAji4+ORnp6O7OzsH9w8iRofNBmgKIqaZKxWK7RaLcrKynD+/HmUlJRgYGAAACCRSBAYGIioqCgEBgZCqVTC19cXnp6eEIvFIITAZDKBz+eP6QWZYRhotVqoVCr09PSgs7MTLS0tqK+vR39/P3Q6HdhsNoKDg5Geno709HSEhYVBLBaPWQzU9dFkgKIoapKwWq1QqVRob29HTU0NTp48ieLiYjAMg+joaMTHxyMxMRGJiYkIDg52aqyEEFgsFtTU1KCiogLl5eWoqKhAR0cHfH19kZKSgtTUVERERMDPzw9yuZy2FowjmgxQFEW5MFsVrtPp0NfXhzNnzuDbb7/FqVOnAAB5eXm4/fbbkZ6eDrlc7sxQf5BtKmJ+fj62bt2KU6dOwd3dHZmZmVi6dCnmzJkDDw8P8Hg8mhSMA5oMUBRFuShb9W21WvHBBx/gtddeQ1dXF2JiYrBu3Trcc889kMlkLnnxLC0txYcffogDBw6gq6sLaWlpeOGFF5Cenm5fs8AVz2uioskARVGUixoeHkZxcTGeeeYZFBcXY+3atbjzzjuRkZEBqVRq35bYFS+aDMOAYRh0dnbi5MmTeOutt1BYWIj77rsPjz/+OEJDQyEQCJwd5qRBkwGKoigXQwhBUVERdu3ahe3bt8PHxwe//e1vkZKSAm9v70m14p/FYsHIyAi6u7vx1Vdf4aOPPoKXlxfuvPNOLF++HCEhIc4OcVKgyQBFUZQL0el02L17Nw4ePIimpiaEhoZi3bp1mDlzJjw9Pe2tAZMJIQRWqxXNzc3Iz8/Hzp07YTKZkJSUhJUrV2Lu3LnODtHl0eWIKYqiXAAhBDqdDt988w22b9+OoaEhTJs2DatWrUJubi4A1+wO+DFYLBa4XC4iIiKgVCrB4XBw8OBBFBcXY2RkBHw+HzNmzKDLHP8MNBmgKIqa4BiGgdFoRGFhIV555RWwWCysWrUKa9euRVhYmLPDcxgWiwWJRIK7774bUVFR2LZtGw4cOACtVgulUonAwEBwOByaENwEmgxQFEVNYLYlf6urq7Fx40Z4eXnhhRdeQHZ2NqRSqbPDcwoWi4XMzEwEBQUhJiYGf/jDHzAyMoI333wTPj4+o1ZIpH4cOmaAoihqAtPpdPZR9HK5HFu3bkVgYKB9aeCpzNZ1UlBQgFtvvRUrV67E73//eyQlJU35z+anmhzDTSmKoiYhk8mEb7/9Fs8++yzc3NywefNmmghcgcViQSQSITMzE2+//TZOnTqFf//73/YFl6gfj3YTUBRFTVDHjx/H3r17odfr8T//8z8ICwujicD3sNlsCIVCLFq0CJWVlcjPz8e+ffvg7++PiIgIZ4fnMmjLAEVR1ATU0tKCgwcPoq2tDTk5OcjNzR3zzYMmCxaLBR8fH6xZswYBAQEoLy/HN998A6PR6OzQXAZtGaAoippACCEghODEiRO4dOkSfHx8sG7dOshksjE/jk6nQ21tLfR6/ai/CQQCJCYmgs/nj3q91WpFYWEhrFar/Xkul4ugoCA0NTXd8JhCoRAKhWLcNklKTU3FkiVLsGPHDuzduxd5eXmIi4sbl2NNNnQAIUVR1ARCCIFWq8XKlSvh5uaGdevW4e677x6X41RWVuK+++5DRUUFTCYTrFYrBAIBYmNj8c0338DPz2/U64eGhpCYmIi+vj4QQsDlcuHj44Onn34ajz76KBiG+cFjxsTEYP369fjf//3fMT8fG61Wi3feeQeffPIJlixZgr/85S90/YEfgXYTUBRFTTAffvghGhoasGTJEtxyyy3jcgwWi4WEhAScP38e77zzjn1XwKeffhqFhYWjEgHb6z09PdHa2opHH30UDz/8MD755BOUlpb+6GPapgKOJ4lEgnnz5mH+/Pn48MMP0dbWBnrPe2M0GaAoipogbE3xb7/9NvLy8pCRkQFPT89xP+6MGTOQlZUFrVaLrVu3wmq1XvcCqlKpUFBQAIVCgezsbACXE4WlS5eipqYGAwMDVz0uXbqEGTNmICMjAwsWLBj387EtUyyRSPDee+/BbDaP+zFdHU0GKIqiJgiz2YwLFy6gtbUVCxYsQGhoqEM2HAoODsa0adPg7e2N9vZ2XLx4ESaT6ZqvPXjwIHx8fBAREQGZTAYOh4PAwECkp6dDoVDA09PzqsfRo0cRHByM+Ph4yOXycT8fHo+HgIAA5ObmYvfu3TAajbR14AZoMkBRFDVBGI1G5Ofnw8fHB3FxcQ5pFQAuD+wLDg5GWloaDAYDDh8+DIPBcM3XHjx4EFFRUfZpjnw+H4mJiVi+fDnEYvGo1xJCYDAY8O233yImJgYxMTHgcsd/3DqLxYKXlxdyc3PR1NSEurq6654PdRlNBiiKoiYIk8mEM2fOYNq0afD19YVAIHDYsZVKJebNmwdCCI4cOQKtVjtqQCAhxN7kHx8fb58RwOVyERoaioyMDAiFwlHvSQhBQ0MDGhsbER8fj9DQUIedj0QiQWpqKlgsFsrKyq6aMUGNRpMBiqKoCcC2B0FpaSnS09OvurCON6VSiezsbAiFQhQUFKCrq2vUPH2r1YpLly7BaDQiLi7uqgGG30cIgcViwe7du+Hn54e4uDh4e3uP92nY8fl8+Pj4ICQkBOXl5dDpdA47tiuiyQBFUdQEYDKZoFKp0NraitTUVIcnAyKRCMHBwcjOzobRaMSBAwfQ1dUF4PKF3WQyYevWrVi6dKl9M6AbMZlM+Oijj7Bq1Sr4+vqO9ylchcvlIj09HaWlpTQZuAGaDFAURU0ABoMBHR0dIIQgMjISPB7P4TFIpVJs3LgRLBYLO3bsQFtbG4DLyYBGo8G2bduwZs0aKBSKG77X8PAwDh8+jO7ubqxevRo+Pj7jHf5VOBwOIiMj0d7eTlcjvAGaDFAURU0AJpMJg4ODAGAfpe9oYrEYCxcuhLu7O6qrq1FdXY3+/n4MDg7i+PHjCAwMRGxsLEQi0Q3fS61WY+vWrbj11luddj4sFgsymQxDQ0OjVk2krkaTAYqiqAmAYRj7iHehUOiUFfPYbDbkcjkyMzMBAJcuXUJtbS0GBwdx7NgxLFiwAGKx+IZdBCMjI2hubsa5c+ewatUqp50Pi8WCm5sb9Hr9DVdHnOpoMkBRFDUBsFgs+92zs+5iWSwWuFwuFi5cCKFQiKKiIpSWlqK7uxuFhYVYvHjxj5oa2NPTg7KyMrBYLMyaNcsh0wmvx2q1gs1m0+WIb4AmAxRFURMAl8uFRCIBAGg0GqfdybLZbOTl5cHd3R01NTU4d+4cKioqoFarMXv27Bte2BmGQV1dHQoKCjBjxgz4+fk5ZOGk68UyNDQEqVTqtBhcBf10KIqiJgAejwcPDw8Al5f8dWbrQGJion0Pgf3792Pz5s3Izc2Fu7v7De+wdTodqqqqUFZWhvXr1zsi5OsihEClUsHT09OprROugCYDFEVRE4BYLEZYWBiEQiFKS0udPvp99erVCAoKQk9PD1Qq1Y++sOfn56OoqAh+fn5YtmzZOEf5w6xWK4qLixETE/OjBj1OZTQZoCiKmgDYbDbEYjESEhJQVFTk9OVzly1bhqCgIEilUoSFhdkHFf4QQgiOHTsGtVqNZcuWOfVunBACs9mMwsJCJCUlXbVUMjUabTehKIqaAFgsFgQCAdLT03HmzBmMjIyAEOK0gW++vr74v//7PwwMDEAul//oGQH33nsvdDodfHx8nDpoT6fTobKyEmq1GikpKXBzc3NaLK6AJgMURVETBJ/PR05ODr788ks0NjZCoVBAKpU6JRaBQICMjIyf9P+wWCwkJCSMU0Q/zeDgIE6fPg2FQoGYmBiHr+joamg3AUVR1AQhEAiQlZUFNpuNCxcuoKenx9khuSSLxYLe3l6cOHECaWlp8PPzc8qKjq6EJgMURVETBIfDgb+/P2bOnIlDhw6hvr6erpx3E4aHh1FXV4eLFy/i9ttvpzMJfgSaDFAURU0gLBYLv//971FXV4djx46huroahBBnh+UyCCE4e/YsPv/8c/j7+2PDhg00GfgRaDJAURQ1wcyePRuLFi3CqVOnsH37dphMJmeH5DLq6upw6NAh1NXV4emnnwafz3d2SC6BJgMURVETiG1J4Iceegj+/v44deoUvvjiC2eH5RL0ej0+/vhjlJSUYObMmViyZAlYLBZdivhHoMkARVHUBBQXF4fc3Fy4ublh586dKC0tpd0F10EIAcMw2LlzJwoKCuDv7481a9ZALpc7OzSXQZMBiqKoCUgikSA3Nxfp6elob2/H1q1b0d/fT3ffuwZCCEpLS/HZZ5+Bx+Nh7ty5yM7Opi0CPwFNBiiKoiaomJgYLF26FLNnz8b777+PI0eOOHUTo4mGEAKr1Qq1Wo1XX30VVVVVuPXWW7Fs2TKnrc/gqugQS4qiqAksNTUVXl5eUKvV+OUvf4mPPvoIOTk5kMlkU/rO19Zl0tfXh7/+9a/4/PPP8c4772Dp0qVQKpVOjs71sAjthKIoipqwCCEghECj0eCXv/wlDh06hMceewxr1qyZMKv9OYPFYsHp06fxz3/+E4cPH8Ybb7yB22+/HW5ublM6SbpZNBmgKIqa4GwJQWdnJ/72t7/hxIkTiImJwdq1a7F69eopN4++t7cXn332GXbv3g21Wo0nnngCt912G6RSKdhs2vt9M2gyQFEU5QJsVXVJSQl27dqFixcvwmq1Yv78+bj33nudvjGQIxBCUFhYiE8//RSlpaXw8PDAkiVLsGLFCiiVykl//uNpaqWTFEVRLsp2oZs+fTo4HA48PT2Rn5+Pr7/+GiwWC7m5uYiLi4NIJJp0d8cWiwXDw8O4cOECvv76axQXFyM8PBx5eXlYvHgxfH19nR2iy6MtAxRFUS5IrVbj/PnzePPNN1FWVoZbbrkFd9xxB8LDwyGTySASiVz+TtlqtWJkZAS9vb2oqKjAW2+9hbq6OqxYsQJ33nknUlNT6QZEY4QmAxRFUS6KYRhoNBp88MEH+Nvf/gaJRIIVK1bg1ltvxaxZs8Dn8+2tBK6SGNguSRaLBQMDA8jPz8eOHTtw4MABhIaG4qWXXsKsWbMgkUicHOnkQpMBiqIoF3Vl9d3e3o7XX38de/bsQW9vL+Lj4/HLX/4Sa9euhVAodJlkgGEYdHR04IMPPsDWrVvR09ODqKgo3Hfffbj//vvtLQGucj6ugiYDFEVRLs62HO/IyAg6Ojpw9uxZ7NmzB2fOnIGXlxdWrFiBpUuXYtq0afD29nZ2uFexWq3o6OjAuXPnsGfPHhw5cgQCgQCLFi3C0qVLkZGRAU9PT4jFYgA0ERgPNBmgKIqaRIxGIwYGBtDW1oa6ujocP34cVVVVIITA29sbERERSE1NRXp6OsLDw8HhcBx+cSWEQK/Xo6ysDIWFhSgvL0djYyMGBwfh6emJtLQ0zJ49G2FhYfDz84OHhwc4HI5DY5xqaDJAURQ1CTEMA61Wi6KiIhQVFaG2thZ9fX0wGo3g8/nw9/dHaGgo/Pz84OvrCy8vL8jlcnh5eY3Zwj229REGBgYwODgIlUqFvr4+9PT0oKOjAw0NDRgaGoLFYoGbmxsCAgKQkJCA9PR0xMTEgM/n01YAB6HJAEVR1CTHMAyam5tRUVGB4uJiXLp0CS0tLbBYLPDw8EBgYCCCgoIQEBCA4OBg+Pr6QigUgsfj2R9cLhdcLhcsFgtsNhtsNtvePWHbI8BqtcJsNsNiscBsNsNkMkGr1aKjowMdHR1oa2tDW1sburu7odFoIJVKER8fj+TkZCQnJyM+Pn5CdmNMBTQZoCiKmmIsFgtqa2tx5swZvP/+++jo6IDJZILRaATDMJBKpQgKCoKXlxdkMhnkcjk8PT0hkUjA5/MhEAjA4/FACIHBYLBPAdTpdFCpVPaWgJ6eHrS0tIBhGHsi4e7ujtTUVNx1112YNWsWvLy8ptwKihMRTQYoiqKmIEIIqqqqsHbtWsyePRsbN25EdHQ0ampqUFlZiebmZvT19aG/vx/9/f1Qq9XQaDQwGo3Q6/UwmUxgsVgQiUTg8XiQSCSQSqXw8vKCQqGAl5cXlEoloqOjERsbi4iICOzduxefffYZTCYTDh8+DBaLRbsBJgiajlEURU1RL730EoRCIebNm4esrCxwOBz4+PggKyvL3vz//QcwekrjlRdz28Xd9rB1J9geCxYswNDQEJ5//nns3r0bK1eupAMDJwiaDFAURU0xVqsVdXV1OHToEO69915Mnz591HiA8eLj44Pp06cjJSUFb7zxBpYuXQo2m01bByaAybWANUVRFHVDRqMRO3bsAJ/PR1ZWFoKDgx1yQebxeAgLC8Mtt9yC0tJSFBYWwmAwjPtxqRujyQBFUdQUYjab0dfXh127dmH27NmIi4uDu7u7w46vUCgwb948SKVS7NmzB8PDw6BD15yPJgMURVFTiFartS/0s3HjRnh5eTm0mV4oFCIkJAQrVqzA1q1b7TMZKOeiyQBFUdQUQQhBa2sr3nzzTWRkZCAnJwdSqdThcbi5ueHxxx+HSqXCvn370NLSQlsHnIwOIKQoipoiOjo6cOrUKRQWFmL79u1O2/6Xw+EgJCQEd999N7Zu3YqYmBiEhYXR7YidiLYMUBRFTRHnz5/HgQMHMHPmTGRmZjptWp9t6uEjjzwCAMjPz8fFixedEgt1GU0GKIqipoCmpiZcuHABPT09WLduHcRisdOn9IWHhyMzMxP19fU4ffo0HTvgRDQZoCiKmgLOnTuHuro6+Pj4ICcnx9nh2FcvXLZsGQCguLgYdXV1To5q6qLJAEVR1CSn0Whw9OhRDA8PIysrCxEREc4OyW7+/PmIjIxEZ2cnDh48CKvVSgcTOgFNBiiKoiYp2xLC+fn5uHTpEoKCgrBq1SpnhzWKh4cHcnJyIJPJsH37dgwPDzs7pCmJJgMURVGT3D//+U8oFArMnz8fMTExzg7nKosXL8aCBQvQ09ODd99919nhTEk0GaAoipqkGIbB3r17UVZWhoULF2LOnDlOHzR4LW5ubkhNTcX8+fPx7rvvYnBwEAzDODusKYUmAxRFUZMQIQQWiwUffPAB4uPjkZqaCqVS6eywronNZiMqKgrLli2DVqvFzp07YTQanR3WlEKTAYqiqEnIaDSivLwc586dw+LFixEWFgaBQODssK7Lw8PDnrRs27YNAwMDsFqtzg5ryqDJAEVR1CRDCIFGo8G+ffvAZrOxcOFC+Pj4ODusH8TlcuHj44PVq1ejoKAAVVVVGBkZcXZYUwZNBiiKoiYZq9WKnp4efPrpp1i5ciUiIiIgEomcHdYNeXh44Pbbb4dMJsO2bdvQ2dlJpxk6CE0GKIqiJhFCCBobG/HVV1+hvb0dTz75JNzc3Jwd1o/CZrMhlUrx6KOPYseOHSgrK4NGo3F2WFMCTQYoiqImEavVitLSUuzYsQMbN25EWFiY0/YguBlcLhcPPvgg/Pz88PXXX6OgoMDZIU0JNBmgKIqaRC5duoSTJ0/CZDLhgQceAJvNnpDTCX+IRCLBhg0bUF1djXPnzmFgYMDZIU16NBmgKIqaJCwWCwoKClBfX4+0tDTExcU5O6SfjMVigc1mY/ny5fD09ERVVRVtHXAAmgxQFEVNEi0tLSgqKoLZbMaSJUsglUpdrlXAxjbNUK1W49ixY9DpdM4OaVKjyQBFUZSLI4SAYRh8++23aGxsREhICBYtWuTssH4WLpeLRYsWwdPTEwUFBWhoaHB2SJMaTQYoiqImAZ1Ohy+++AJeXl5YuHAhFAqFs0P62ebNm4esrCwYjUa8++679o2XqLFHkwGKoqhJ4O2330Z7eztycnJcvlXAhs1mY86cOcjJycGXX36JmpoamgyME5oMUBRFuTCGYaDRaLBp0ybMnTsXqampkEqlzg5rTLBYLMTExGDBggVQKBR44403YLFYnB3WpESTAYqiKBdmMpmwb98+9Pf3Y/HixYiKinKpdQVuRCgUIjw8HMuWLcM333yD5uZmmEwmZ4c16dBkgKIoykUxDIPh4WFs374dcXFxSE5Ohlwud3ZYY4rFYsHHxweLFy+GRqPBsWPHoNVqnR3WpEOTAYqiKBel1+vR2NiIY8eOYe3atVAqleDxeM4Oa8xJpVKkpaUhNTUVX375Jbq7u2l3wRijyQBFUZQLIoSgvb0dn3zyCYRCIdavXw8PDw9nhzUuWCwWxGIxHn30UZw9exYXL15Ef3+/s8OaVGgyQFEU5YJ0Oh0qKyuxY8cO/Pa3v4WnpyfY7MlbpfP5fCxfvhzp6en49NNPUVxc7OyQJpXJ+82hKIqaxAoKCrBnzx7IZDLcd9994HA4Lrva4I9hO7cnnngCjY2NOHXqFOrr650c1eRBkwGKoigXMzw8jAsXLqCmpga33347ZDKZs0NymDlz5iAhIQHl5eU4efKks8OZNGgyQFEU5WKKiopQWVkJkUiEW265ZdK3CtiwWCx4eXlh0aJFMBgMOH/+PDo6Opwd1qRAkwGKoigXYjAYcPjwYfT09CAxMRGpqanODsnh8vLy4OPjg/r6erqj4RihyQBFUZQLaWtrQ35+Pjw8PLB8+fJJOZXwRqKjozFjxgwAwBdffAGz2UyXKf6ZaDJAURTlIgghePPNN6HVajFr1izk5OQ4OySnueWWW5CdnY1z587h6NGjAEATgp+BJgMURVEugGEYNDQ0YNu2bViwYAFycnLA5XKdHZbTBAcHIzMzE7GxsXjhhRfAMIyzQ3JpNBmgKIqaIKxWK3p6elBVVQWj0TjqbxaLBe+88w4kEglycnIQHR09JQYNXg+bzUZcXBzWrVuH0tJS5Ofnj9qzgBACo9GIkydPwmq1OjFS1zB100qKoqgJxmKxoK6uDm+//TYyMjKQmZmJqKgouLm5obOzE3v37sWCBQsQGRkJNzc3Z4frdAqFAmlpaQgLC8Nnn32G6dOng8fjobe3F+Xl5cjPz0dZWRlSU1MhFoundPJ0IzQZoCiKmiCsVisaGhrw5ZdfoqysDI2NjZg5cyYCAwPR1NSE7u5uLF++HL6+vvTChss7GgYGBmLp0qX2VQlZLBaqq6tx5swZHDx4EP39/RgeHoZQKJxUuzmONZoMUBRFTRBWqxVtbW1gs9moqKhAWVkZvvrqKyQkJECr1SI4OBhpaWlwd3d3dqgThlQqxapVq/Dyyy9j06ZNqK+vR319PVQqFYDL3QU9PT2QyWQ0GfgBNBmgKIqaICwWC5qbmwHA3s/d3t6Orq4uMAyDzMxMtLe3QyKR2Ju9p2oLASEEhBCYzWb09PTAx8cHn332mX1GwZUzC1pbWxEeHg6hUOiscCc8OoCQoihqgrCNGbhyIBzDMDCbzbBarTh37hyys7Oxdu1abN68GT09PU6M1rkaGxvx73//G3l5ebj11lvR3d0NhmHsSYINl8tFU1PTVQMyqdFoywBFUdQEYbVa0dTUdN358rYk4dSpUygrK8PWrVvx0EMP4bbbbnNglM5DCAHDMHjxxRexf/9+1NfXQ6vV/uBsARaLhdbWVpoM3ABtGaAoipoAGIaB0WhEX1/fDV+r1+thNBrh5uaG6OhoB0Q3cbBYLMTHx0MoFGJwcPCGF3mr1Yr29vZRrS3U1WgyQFEUNQGYzWYMDg7CYDD84OtYLBZkMhkyMzOxYsUKhIWFOShC52OxWGCz2cjIyMDy5csxY8YM8Hi8Hxw3wTAMTQZ+BNpNQFEUNQEYDAZ0d3ff8HXu7u6YMWMGNm7ciBUrVkzJQXFBQUHYsGED3N3dMTw8jJqamh9sIbAlA4SQKTvg8kZoMkBRFDUB6PX6G27Hy+PxMHv2bPz5z3/G9OnTp/RyxH5+fli7di1CQ0Nx//33o6en57p3/93d3bRl4AZoNwFFUdQEoNPp0Nraet1dCPl8Pm699VZs2bIFqampdM48LreSzJ07F4cPH4a/vz8EAsE17/xNJhP6+vqg0+mcEKVroMkARVHUBKDT6dDW1nbNv8nlctx555145513IJfLp/T6AldisVjg8XgIDw/Hvn37kJycDKlUCjb76ktbZ2cnhoeHnRCla6DJAEVR1ASg1+vR3t4Oi8Uy6vmQkBCsWbMGTz31FGQyGU0EvofFYoHD4SAiIgIvvvgi5s+fDy8vr1EJAZvNRk9PDzQajRMjndimbocTRVHUBGIbM3DlGgNRUVFYuHAh1q1bh/j4eACgicA1sFgsCAQCzJ49GwMDAxCLxThy5Aj6+/vBMAzYbDb6+vowMjLi7FAnLJoMUBRF3QTbAjgWiwUmkwkWi8X+nG0VPA6HY58Ox+FwwOVywePxrhr4RwiBXq8fNZsgODgYy5Ytw+rVqzF37lxHn55LEolEWL58OXg8HkwmE44dO4aBgQGwWCz09vZeMxkghMBiscBsNsNiscBqtYIQYv/XVn62x5VleK3uCFdFkwGKoqjrsF3crVbrqIftOaPRCLVabd8Zz/ac0WgEIQRCoRB8Ph9CoRBubm7w8PCAp6cn3N3d7QkCh8MBIQTDw8MYGBgAAIjFYtx///1Yv349YmJinPwpuBahUIilS5ciMDAQIyMjOHHiBAwGAzo7O6FWq6HT6a4q08HBQQwODmJoaAharRYMw9hXNuRyueDz+eDz+RAIBHB3d4e3tzfc3d0hEAjsSYKtLG0PV+vOYZHrrXtJURQ1hVyrKjSbzejt7UVVVRWqqqpQWVmJmpoatLW1ob+/HxqNBgzD/KTjsFgsCIVCBAQEIDIyEpGRkfD29kZzczM+/PBDsNlsvPzyy7j33nvh6elp/3+oH+fKjYoGBgZw//33Y9++fVAqlViyZAnCwsLQ0NCA2tpaNDY2or+/396q81PweDy4u7tDqVQiLCwM8fHxiI2NRVxcHMLDw+Ht7X3V/zORy5EmAxRFUYB9B7xLly7hyJEjuHDhAqqqqtDd3Q2LxQJ3d3dER0cjIiICQUFB8Pb2hlwuh0KhgLe3Nzw9PcHhcCAQCOxT3AwGg72lQKvVYnBwECqVCv39/ejq6kJ9fT2am5vR0tKCvr4+mEwmSCQSLFq0CFlZWZg9ezaio6Mhl8ud/fG4DIZh0NXVhbKyMpw5cwZHjx7FuXPnYLVaIZVK4evri9DQUISHh9sv2l5eXpDL5fD09LTPRpBIJOBwOPZuIJPJBKPRiMHBQfT29kKlUkGlUqG3txdNTU2oq6tDY2MjzGYzxGIxAgICMH36dMyaNQtLliyBv7//daeNTgQ0GaAoakprbGzEpUuXcOHCBRQVFaGtrQ0SiQQhISEICQlBWFgYIiMjoVQqIRQKIRQKIRAIwOVyR/UfXzk+wHYHeOX4AVuTtK1/2mw225OFwsJClJaWwmAwgMfj2ZMEq9UKhUKBuLg4zJ49G0uWLLlqpDx1+XMuKyvD0aNHcfHiRTQ2NkKj0UAikSAiIgJRUVEoKytDZmYmsrKyIJfLIRAIIBQKR5Wf7V8A9n9t5Xdll5FtfIGtLI1GI/R6PXQ6HVpaWtDU1ISmpia0traisbERPB4PMTExSElJwYwZM5CSkjLhEjyaDFAUNaXYNgS6ePEizp8/j4qKCvT399vvHMPCwhATEwOlUglvb28oFAooFAq4ubmNW0wdHR3o7e21D1jr7OxER0cHmpub0dnZiYGBARgMBgQFBSEtLQ0pKSmIjIyEQqEYt5gmOlsXTnl5OQoLC1FUVISRkRGIRCIoFAoEBQUhLCwMfn5+8PPzQ3d3NwIDAxEUFASRSDQuMTEMg8HBQajVavT19aG3txft7e2orKy0D2AUCAQICgrC9OnTkZmZicjIyAmxkiRNBiiKmhKsViuGh4fR0dGByspKHD16FFVVVWAYBv7+/oiPj0dSUhJSU1MRFBTk0Ltv28j1Ky8KFosFbW1tqK2tRUVFBYqLi9HQ0ACZTIbo6GgkJCQgLi4OoaGh8PPzAzCx+6THgq2FpaOjA42NjSgvL0dRURFqa2vBZrMxffp0JCYmIj4+3t6a8/3/F4DDLr62mQoVFRUoKSlBWVkZGhoaoFKpIJPJkJycjFmzZiEiIgJKpRLu7u5OK0OaDFAUNWnZqjedTgeVSoXy8nIcOnQIe/fuBQDMmzcPixcvxowZMxASEuLMUH8QIQRGoxFHjhzBzp07ce7cOZjNZkRHR+PWW2/F0qVL4eXlBT6fPym7EGzN9FqtFp2dnThw4AC+/fZb1NfXw83NDXPmzMG6deswY8YMCAQCZ4d7XRaLBe3t7Thz5gz27t2LEydOwNvbG8uXL0dubi4SExPh4eHhlHOgyQBFUZOSrWqzWCzYtm0bPvroIxQVFcHDwwP33HMP/r//7/+DTCZzyYtnXV0d9u7dix07dqCwsBBJSUl4+eWXkZKSYu/OmCytBFcmAps3b8Zf/vIXGI1GzJ8/H2vWrMGyZcvg4eHh7DB/MoZhUFxcjH/84x84cuQIuFwu5s2bh8cffxwpKSn276WjypEmAxRFTUpmsxllZWV4/PHHUVpaiszMTKxbtw4rVqyAp6enwyvbsWQbzDY8PIzi4mL8+c9/RkFBAVavXo37778fmZmZEIvFzg5zTHR1deH48eP4xz/+gbKyMjz00EP4r//6L4SFhUEkErncfH4b26WXYRjU1dVh586d2LZtGxoaGnD33Xfjueeeg1wud9iGVDQZoChqUiGEoL29Hdu3b8drr72GgIAAPPTQQ8jIyEBAQADEYvGk2fHPNhhSpVJh+/bt+Oyzz2C1WjFv3jw88MADSEhIcHaIN40Qgn379mHr1q24ePEiQkJC8PjjjyM1NRWenp7g8XgumQRci9lshlarRVNTE/bv348PP/wQvr6++MMf/oBZs2Zdc82CsUaTAYqiJg29Xo/Tp09j7969OHv2LKKjo7Fx40YkJydDLpeDz+c7O8QxZ6vCW1paUFhYiP3796OhoQFKpRIbN27EsmXLXOqiSQjByMgI3n//fRw8eBAMwyAxMRHLly9HSkqKUwfZjSdCCAwGA9ra2lBQUIBNmzaBz+cjNzcXixcvRkpKyrge3/nzGSiKosbAyMgIjh07hn379qGyshKxsbHYuHEjcnNzR839n2xs5xUaGgofHx9IpVIcPHgQFy9exMcffwypVGofWDfRPwOr1QqtVoudO3di165dcHd3x9y5c5GXl4e0tLQJH//PwWKxIBKJEBUVBT8/P+h0Ouzbtw/5+fnQaDSwWCz2z2A8PgeaDFAU5dIIITCZTCgsLMQHH3yArq4upKWl4dFHH0VsbKyzw3MosViMhQsXIjw8HF9//TXeeustvPnmm3B3d0dUVBTEYvGEvaBarVYMDQ3h/PnzeOWVV+Dt7Y377rsP2dnZ8PHxcXZ4DsNisSCRSPDQQw8hMDAQW7ZswaFDhzA0NAQvLy+EhobaXzemx6XdBBRFuSrbQLrq6mrccccd4HA4uPfee3H33XfDy8vL2eE5lUajwaFDh/Dggw9i9uzZ+OMf/4i0tLQJ2ddu20fgzJkzeOSRR+Dr64uPP/4YERERE3qqoCOUlpbis88+w+bNm5GdnY1NmzbZk7qxLEeaDFAU5bLMZjPa29uRl5cHuVyOl156CTNnzoRQKJxwFzxHs03JO3XqFH7xi18gMTERDzzwAFavXj3hPpvBwUF8+eWXePnll+Hr64vdu3fD09PTZWcKjCVCCHp7e3HkyBE89NBDWLt2LV5++WXIZLIx/Wxcb4ItRVEULq8fUFNTg3vuuQc8Hg/vvPMOZsyYQROB79gupLNmzcJrr72GgYEBvP/++/jiiy+cHdooBoMBr732Gt5//32Eh4fjo48+oonAFVgsFry9vbFkyRK89dZb2LFjB1599VU0NjaO6XFoMkBRlEuqrKzEp59+itbWVrz44ouIjo6micD3sFgs8Pl8zJs3D7/4xS/A4XDw+eefo7y83Nmh2X3xxRfIz89HcHAwnnrqKQQFBdFE4HvYbDbc3d2xaNEiPPDAA9i1axeOHz+Ozs7OsTvGmL0TRVGUg3R1deHMmTM4deoU8vLyMH/+fIjFYpdcTdAR5HI5Fi1ahLS0NKjVanz66acwGAxwZi8xIQS1tbXYtWsX3NzcsGDBAsycORN8Pp8mAtfA5XLh7e2NO++8E56enjh69CgKCgpgNBrH5v3H5F0oiqIchGEYXLp0CWfPnoXZbMa9994LDw+PMb+A6HQ6NDY2oq+vb9TzQqEQMTExV21Ba7FYUFxcDI1GY3+OxWJh7ty59iRFr9dDrVajra0NBoMBWVlZDtvjPjo6Grm5uejo6MCuXbuwfv16TJs2zSkLMNkGfu7fvx/19fVYv349FixYAKlUOubH0Wq1KCoqAsMw9udt0/hmzJgx6ntj2wPi7Nmzo95HoVAgMTHRPg6jp6cHKpUKWq0WJpMJHA4HEokEfn5+47ogEpvNRnp6OlauXImdO3fixIkTSExMRFRU1M9/c0JRFOVChoeHySOPPEKys7PJ//3f/43bcerq6sh9991HPDw8CJ/PJwCISCQiycnJ5Pjx46NeyzAMGRoaIrm5uUQikRCBQEDc3NyIj48PMZvNxGKxEK1WS8rKysirr75KwsLCCIfDISqVatzivxa9Xk8OHz5MIiMjya9//Wui0+kIwzAOjYEQQqxWKxkYGCDR0dHkzjvvJGfOnBmX45jNZlJaWkoCAwOJWCwmHA6HcDgc4uHhQWbOnEksFstVr29rayNeXl6Ez+cTkUhEPDw8yMaNGwnDMMRqtZK+vj7yxhtvkHXr1pHp06eTkJAQEh0dTZYsWUI++OAD0tHRcdX7jrXBwUGyceNGkpubS/7xj3+MyfFoMkBRlMtgGIZ8+OGHZNasWeTee+8lXV1d437MgoICsnbtWsJms8kzzzxDBgcHr3sBZRiGvPfee+Tee+8l//73v+3PNzc3kz/+8Y9k3rx5JCYmhkilUqckA4QQ0t7eTl588UUiFApJZWUlMRqNDj0+wzBEo9GQV155hUgkEnL8+HGi1WrH/bj/93//R+Li4khcXBx5+eWXf7AMGYYh69evJ88++yw5d+4cIeRyAjM0NETmzZtHpk+fTv7xj3+QqqoqMjQ0RGpra8maNWsIn88nmzZtIj09PeN+Pnv27CGrV68mmZmZpKWl5We/H+1goyjKJZDvmmg/+eQT+Pv7Y/HixQ5ZjCY0NBS33norGIbB559/Dq1We93XDg4OoqSkBAMDA1i5cqX9+TfeeANmsxlPPfUUPvzwQ0gkknGP+3qUSiXuuusueHt748MPP0R/f7/DY9BoNHjrrbdwzz33ICYmxiGbKi1btgwxMTFobW3Fnj177N+n7yOEoL+/H8ePH8fMmTPtC1cNDQ3hT3/6E0pLS/Haa6/hwQcfRHR0NKRSKcLDw/H22287dBfMhQsXYu7cuTAYDPj4449/9vvRZICiKJdx/vx5NDU1ITExEenp6Q6peOVyOaZPn46goCB0dHTg4sWLGBgYuOZrT506BYvFgoSEhFGbyzz88MN45JFHMHfuXKfvJmgbmb5y5Urs378fKpVqVH/6eBscHMTFixfR3t6O22+/3WF7DcTFxdkTj5aWFpw/f/6ar7NYLPj6668xbdo0BAcHw83NDSaTCR0dHdi6dSvy8vIQFhYGNzc3+zLXbDYbnp6eOHjwIG655RbIZLJxPx+BQID4+HjEx8dj3759MJvNP2tAKE0GKIpyCYQQnDhxAlKpFNHR0fDz83PIcXk8Hry8vDBnzhyYzWbk5+dfNajQ5vTp0+Dz+UhJSRk1MDAkJASBgYFwd3d3SMw/hMViQSAQ4JZbbkFnZyfq6uowODjosOOrVCqcO3cOAQEBSEhIcNgKg2KxGHFxcYiNjcXw8DAOHz58zYunxWLBvn37MGfOHHh5eYHD4WBwcBClpaXo6+tDenq6PRGwYbFY4HA4SEpKgpeXl0MGhbJYLERERCA1NRXNzc2ora39WUkdTQYoinIZBQUFCA0NRUBAANzc3Bx2XDc3NyxatAhsNhunTp1CV1cXrFbrqNeo1WpUVlbC09MTiYmJo/7G5XIn1LRHLpeLtLQ0cLlc1NbWOrSrYGBgAKWlpUhKSoJMJnPobIb4+HhMnz4der0eR44cgclkGpUQWCwW9Pf3o7i4GFlZWfDw8ABwuYugvLwchBAEBwejvr4eR48exe7du7Fz50588803uHTpEnQ6nUNbWZRKpb0bo6Sk5Gcdm04tpChqwiOEwGq1ory8HKtXr3b4vgMikci+lkFJSQmam5uRkpJiv1gQQlBaWgqNRoPAwEBERkY6NL6fis1mQ6FQIDQ0FM3NzVCpVA45LsMwGBoaQn19Pe666y6HrycQHR2N5ORksNlsnD9/Hj09PQgICACXe/lSODIygpKSElitVqSkpNjHdoyMjKCpqQnA5emh27dvR2lpKTo6OmAwGCCRSJCcnIxHHnkEsbGxkEgkDjk3sVgMpVIJf39/FBcX4/bbb7/p95o4qSpFUdR1MAwDtVqN1tZWREdHXzXHf7xxuVz4+/tjzpw5YLFYOHv2LCoqKgDAfme5c+dOJCUlITo62ilz92/G9OnT0dLSct1uj7Gm1+vR19eH3t5epKSkOLy1xMPDA1FRUUhLS4PBYMCePXug1+sBXC5HlUqFvXv3YvXq1RCJRPYLutFohEqlAiEEzzzzDBoaGvCrX/0K+/fvx6FDh/DII49g+/bt2LBhA86fPz9mCwH9GG5ubpg2bRqKioquaq36KWgyQFHUhGe1WtHa2gqGYRAaGuqUvnc2m4277roLYrEYx44dQ2Fhof1vBoMBu3btwuzZsxEfH+/w2G5WREQE1Gr1qIWSxtPg4CB6e3vB4XAQHR3tlJUGQ0JCsHr1ajAMgy1btthnh1itVnR1dWHfvn245557wOfz7f8PwzD2C7xIJMILL7yA5cuXw9/fH8HBwbjrrrvwu9/9Dl1dXdiyZct1ByeOB5FIhNDQULS0tNAxAxRFTW4Mw9hH8Ht4eIyqqB2FxWJh0aJF8Pb2Rnt7OyoqKtDW1gaLxYIDBw7Az8/PKa0WP4dMJoNOp3PYnaxer4dWqwWbzXbIiPtrUSqVmDdvHqRSKUpLS1FbWwutVovm5mYUFRUhODgYsbGxo1otOBwORCIRACAzMxPu7u72mQQsFgtcLhd5eXngcrkoLi5GS0uLw86Hy+XCw8PjujNcfiyaDFAUNeERQqDX60EIgUAgcFozvKenJ2bOnAmpVIr6+nqcP38eZrPZPvpcoVC4TBcBcLnP2WQywWKxOOR4ZrMZJpMJLBYLQqHQIcf8Pj6fDx8fH2RlZcFoNOLEiRPo6elBY2MjKioqkJube9X+CAKBAF5eXvYdBDkczqi/s1gs+Pn5gc1mY2BgACMjIw47HzabDZFIBJ1OR6cWUhQ1udnuvoDLzbmOHLF9ZQwcDgdz586Fj48PmpqacPr0aajVapw9exY5OTn2AYWuwmKx2O9wHYHNZoPNZtsHhDoDi8WCRCLBwoULwWKxcOLECTQ1NaGpqQmtra3Izc296v9xc3NDaGgoAFw3cbJ9J52x46LVarX/Pm4WTQYoiprwWCyWfXEarVYLs9nstFiys7Ph7++P3t5enD17FkVFRVCr1UhLS3PqyoI3Y3h4GCKRyGHdLgKBAGKxGIQQDA8PO+SY1yISiZCbmwuRSISioiKcP3/ePk8/IyPjqtd7eHhg2rRp4PF4aG9vv2pKIiEEHR0dYBgGPj4+Dh3TYrFYoNFofvbiTTQZoChqwrOt8AZcHoRmMpmcFktMTIx9+lhZWRn+8pe/YMGCBQ6fMz8W1Go1xGKxwxb+EYlEkEgkYBjGPjrfGfh8PqZNm4bo6GiMjIxg06ZNKCsrw6xZsyD9/9u705ior/2P4+9B9kFknaEsCiIqikIRUhQUF2qKW2jUGmO3SKppbOODNq0xTbrY1ibtE+01auODatyirVSNtagV61oXJCCLoGhlcRhGRIUZHZjfb/4PemfCvfZ2+YszDHxfyUQScOZMDvzOZ875/s4ZPPixQTUsLIyJEycSExPDuXPnaGtro6urC1VVncWFP//8M4qikJmZSUJCgsvei81mo729ndDQUAkDQoj+zdvbm8TERAICAqitrX3iYqknlZubS3p6OmazmaqqKl555RWXHUXcmyoqKoiOjnZZ0WN4eDgxMTF4eXlRXl7utjAAv882LVmyBK1WS319PYMHDyY/P/8Pf9bLywu9Xs/XX3/N/fv3eeeddzhw4ADNzc00Njayc+dOvvrqK0aPHs3LL7/MhAkTXPY+Ojs7qampYezYsU90q6aEASGER/Dz8yMlJYXa2lqXbZLzv2RnZ5OWloa/vz9xcXHk5ub+6azAqVOnmDNnDjqdjmnTpmE0GlEUhVGjRqHT6Vi6dCklJSUua7/jkJ6ysjLi4+NdcuAT/F6VHxYWRmJiIhcvXnRrGPDy8mLBggUEBwcTHh7u3J3wjzgKHvPy8igqKiI8PJw1a9aQnZ3NlClT+Oabb1ixYgV79uwhPT39idfv/y673U5nZydXrlwhMzPziWamZAdCIUSf5yjKysjI4OLFixiNRlRVddsWv2FhYRQWFpKXl4e/v/9fTrOPHTuWjz766H+eAaDT6YiJiXkKLf1jiqJQVVVFW1sbo0ePdlkY0Gg0hISEMGbMGE6dOoXNZnusMt+VnnnmGXbs2IGqqsTGxv5p7YRGo8HX15dJkyYRFxfH/fv3nctVAQEB6HQ64uLi8Pb2dtn7MZlM1NbW0tHRQWZm5hP9PUgYEEJ4BI1Gw7Rp0/jpp5+or6/HZDKh1+vd0hYfHx+GDx/O8OHD/9bPh4WF9an9B7q7uzl+/DihoaGMGDHCWY/hCuHh4WRlZbF3717q6+tJSkpy274Rfn5+5OTk/KP/M2TIkD5z18itW7eoqKhAr9c/tjfCPyXLBEIIj5GVlYVWq+Xq1avU1dW5uzkeSVVVOjs7KS4uJjU1ldjYWJceqxwaGuo8fvrkyZNYLBaXvXZ/0tXVxbVr16iuriY9PR2dTidhQAjR/zk2dsnIyKCuro5ff/3VrbcYeqpHjx5x8+ZNTp06xezZs13+Kdff35/Y2FiysrLYs2cPbW1tbttzwJO1trZSWVlJU1MTc+fOfeLnkzAghPAoy5YtQ6PRcOLECbcXoXkau91OY2Mj69evR6fTsXDhQrdsCxwUFMR7773HmTNnOHHiBEajUfrxH7Db7Xz33XecP3+epKQkXnzxxSd+TgkDQgiPkp6ezvPPP4/ZbGbdunVYrVYZSP4mg8HAyZMnOXz4MB9++KHLjtr9b76+vuTk5JCfn8+mTZs4f/68y7ZE7g/Ky8vZv38/Wq2WwsLCXqm5kDAghPAogwYNoqCggNzcXKqqqtiwYYO7m+QRrFYrx44dY9euXWRmZjJ37lyXVr735NjaedWqVSiKQlFREceOHXN5OzyN3W7HYrGwdu1abDYbubm55OTk9EofShgQQnicoUOHkpOTQ3p6Ort37+by5ctSP/AnVFXl6NGjHD16FEVRKCws7BN3N4wbN445c+Zw+/ZtfvzxR6qrq93dpD7LcZ7D1q1bqaysZOrUqUyfPp3Bgwf3yvNLGBBCeBx/f3/GjRvHrFmzMJvN7Nixw7lnvHjclStXKCoqoqWlhYkTJzJz5ky3HKjTk+PAoIKCAuLi4qipqWH//v20trbKss8fsFqtXLp0ie3btzNixAjy8vIYPXp0r/WhhAEhhEeKiopi6tSpLFy4kK1bt3LkyBFaWlpkhuDfHLsMtrW1sXnzZkpLS0lJSeG1117rM/fJw+81IAUFBYSHh7Nz506OHz/Oo0ePJBD8m91ux2q1cvPmTdavX09TUxNvvvkmqampBAQE9NrryKZDQgiPpdfrWbVqFTdv3uSDDz7g4cOHzJs3j4SEBLd+6nU3x0BqtVr5/PPP2bVrFytXruSll14iOTnZza173Ny5cwkODmbdunW8/fbbhIeHM3nyZPz8/AZ8P6qqSnl5OZs2beKHH35gx44d5Obm9moQANDYJX4JITxUz0Hvrbfe4siRI0yePJlly5aRm5vr5ta5j6IoNDU1sXr1avbt28eXX35JQUEBMTExfXJwdQx6N27cYPXq1Rw6dIh169Yxb948t+0y2Rd0d3ezdetWtm3bRkNDA5999hmLFy9+Kks8EgaEEB7NcQkzmUxs2bKFw4cPY7VaefXVV1m+fLnbKubdpb29nZKSErZs2UJFRQVr164lPz+fkJAQlx2g8/9ht9ux2Wy0tLTwySefUFxczNy5c1m0aBGTJk3q023vbXa7HYPBwBdffMHJkyeJiYnhjTfeIC8vD61W+1R+nyUMCCH6BbvdTn19PSUlJRw/fpwbN24wY8YMVqxYgV6vHxCDSXl5OQcOHODs2bM8fPiQBQsWsGDBAiIjI5/oRDtXccwQXLlyhW3btlFaWopOp2P69OnMnz/fZQcquVN3dzelpaX861//4vr160yYMIGZM2eSnZ1NRETEU3vd/v/XIYQYEDQaDSNGjMDX15eQkBAOHDjA0aNH8fPzY8qUKYwZM4bIyEi3nXT4tKiqSkdHB2fOnOHYsWNUVVURGBjICy+8wPz589Hr9R4zM+LYfyAtLQ2bzUZgYCBlZWUcPHiQjo4Opk2bRlpaWr+c7bFarRiNRi5dusShQ4e4du0aOTk5zJ49m/T09Kd+mJTMDAgh+h2LxcL169f59NNPuXz5MtnZ2cyaNct5oEtwcDCARw8oiqLw6NEj7ty5Q2VlJRs2bODWrVtkZGRQUFDArFmz/vJo5b7OYDBw8OBBioqK+O2335gxYwavv/46sbGxhISE9IsCQ5vNRnt7O42NjVy8eJE9e/bQ0NDAkiVLKCwsJDo62iWzOhIGhBD9kt1up7u7m82bN7Nx40YsFgsZGRksWrSI/Px8/Pz8nEsHnjSgqKqKoig8ePCA6upqdu/ezfbt20lMTOT9998nNzeXqKgodzez1yiKwq1bt9i1axfr1q0jJCSEpUuXkp+f7zz+2DFYeko/Om77tNlsGI1G9u3bx/79+6mpqWHkyJGsWbOG7Oxsly7tSBgQQvRLPS9tRqORPXv2sHfvXkpLS0lISODdd9+loKCA4OBgj1hPd2hubub777+nqKiIy5cvExYWxsqVK1m+fDn+/v6A5wyKf4ejH1VV5fbt23z88cfs378fHx8fJk2axOLFi5k9e7ZHzRJ0dXXR3NzMxo0b+fbbb1FVlSlTprB48WIKCgrcElIlDAgh+j1VVbFardy5c4eqqiq2bdtGcXExISEhTJs2jby8PCZNmsTQoUPd3dTHqKrK/fv3OXfuHDt37qSkpAQvLy8yMzOZNWsW+fn5hIaGOu8795QB8Z9yFBdaLBZu3LjB4cOHKS4upqqqitDQUGexZFJSEkFBQe5u7mNsNhvV1dWcPn2aI0eOcPbsWQIDA50BYMSIEQQFBeHr6+ue8yIkDAghBgqbzYbZbKapqYna2lp++eUXqqqq6OjoQKvVkpiYyMSJE8nKyiI+Pp6AgACXX5jtdjsPHz6kpqaGiooKrly5Qk1NDQaDAZ1OR0ZGBpmZmQwfPpyoqCgiIiI8amajNzx69AiTyURzczPXrl3j9OnTlJWVodFoiIuLIzk5mdTUVNLS0khISMDLy8vl/agoCp2dnVRWVnL27FlKS0tpbGxEURSioqJ49tlnmTJlCvHx8ej1evz9/d1a3CphQAgx4NjtdsxmM5WVldTU1HD9+nUaGhq4d+8e8PvOhjExMURFRREVFYVer0ev1xMZGUlQUFCvXbQdn/rv3btHW1sbRqORpqYmGhoaaGxspKOjA1VV8ff3Jy4ujtTUVMaPH09CQkKvtsNTdXd38+DBA6qqqigrK6O6upo7d+7Q1dWFr68vERERDB06lKFDhxIdHU1ERATh4eGEhIT02uyBY8bi7t27mEwmjEYjRqORlpYWDAYDDQ0NmM1mvLy80Ol0DBs2jJEjR5KSkkJSUhKDBg3qE7M5EgaEEAOaqqqYTCbq6uooKyvj/Pnz3Lx5k66uLoYMGUJkZCR6vZ7o6Gji4+OJjIwkMDAQX19ffHx88PX1dRaxeXl5OR8ajQZFUZynzSmKQnd3N93d3XR1dWG1Wuns7HQOHEajEYPBgMFgoK2tjaCgIBISEkhOTiYtLc15J0RfGDj6GkdBXm1tLeXl5VRUVFBbW0tzczPd3d1ER0c7Q50j4Dn6sWcfent7P9aPqqqiqqqzH202G11dXf/Rj47ZpsbGRgwGA62trdy5c4fOzk6Cg4MZP348GRkZpKamEh8f36fOhnCQMCCEED3Y7XZnMKisrKS6upqrV6/S2tqKoihotVr0ej3h4eGEhoYSERFBaGgoQUFBzoHFx8eHQYMGYbFYUBSFhw8fYrFYePDgAXfv3uXevXu0tLTQ2NiIzWbD29ub4OBgEhISyMjI4LnnnnMO/o6iQPHPWCwW6uvruXDhAhcuXKCiooLbt2/T2dmJ3W4nKCiIYcOGERYW9h+zBVqtFh8fH/z9/fHx8XEO+oqiYLFYMJvNmEwm7t27R3t7OyaTCYPBgKqq+Pn5ERcXx6hRo0hJSXGGgIiIiD4f4iQMCCHEX1AUhfb2diorK6mrq6OhoYHW1lbn1L7JZKKjowOr1ep8OIKDj48PWq0WrVZLSEgIkZGRREREEBMTQ1JSEomJiSQkJKDT6fDx8XH3W+3XzGYzLS0t1NfXU1dXR319PSaTidbWVmdIM5vNWK1WLBaLc7nBEfCCgoIIDg5Gr9c7lxyioqJITEwkOTmZkSNHEhAQ4JHLNxIGhBDiL/S8vc0xZex4OL7f81Lq+Lrnp0HH145DZjQajXM5oedDPD09++2/+7FnX/b8Fx7vx5595ejHnkWKntiPEgaEEEKIAc7z5jKEEEII0askDAghhBADnIQBIYQQYoCTMCCEEEIMcBIGhBBCiAFOwoAQQggxwEkYEEIIIQY4CQNCCCHEACdhQAghhBjgJAwIIYQQA5yEASGEEGKAkzAghBBCDHASBoQQQogBTsKAEEIIMcD9H82Ubv6dcCW4AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from dowhy.utils.timeseries import create_graph_from_networkx_array\n", "\n", From 0317026c4a9cba0d2eecfc0d3b7795d8965ae6b5 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Tue, 30 Jul 2024 03:29:11 +0000 Subject: [PATCH 44/67] removed cell outputs --- .../effect_inference_timeseries_data.ipynb | 5835 +---------------- 1 file changed, 28 insertions(+), 5807 deletions(-) diff --git a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index 26a9c82f4..31500194c 100644 --- a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -11,18 +11,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - } - ], + "outputs": [], "source": [ "import networkx as nx\n", "import pandas as pd\n", @@ -39,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -59,20 +50,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from dowhy.utils.timeseries import create_graph_from_dot_format\n", "\n", @@ -99,20 +79,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Input a csv file with the edges in the graph with the columns: node_1,node_2,time_lag\n", "file_path = \"../datasets/temporal_graph.csv\"\n", @@ -135,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -144,17 +113,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Parents of the target node with respective time lags: ['V5', 'V7'] [1.0, 3.0]\n" - ] - } - ], + "outputs": [], "source": [ "# the outcome node for which effect estimation has to be done, node:6\n", "target_node = 'V6'\n", @@ -166,132 +127,18 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGAAAAAUCAYAAAByKzjvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAABJ0AAASdAHeZh94AAADX0lEQVR4nO2ZW4hOURTHfyNKbqPGZRIJGUoiKYSGFFJKeCQ8KCGSoVzqP4uEB+RaHtSkvHihpOTSjHJLSXkgl3EpQu7JpVzGw96H4zhnnG++880R/i/rnLX3Xvu/zl5nX9Yua2pq4j/yQ5u8CfzraBs8mNkEoD5UdlPS4NYm9LfCzLoBz8I6SWVtY+qeBRqA5xEDs4FqYDgwDOgMHJI0p4WEegMbgKlABfAYOAqYpFctsZmiz63ASKAK6AZ8AB74fvdIelGgvUJ8eA+Yf54P9IX4KahBUq2kPRH9emApbgAeFUI0hvgA4AqwALgM7ADuAsuBi2ZWUYz9ZrAC6AicAnYCh4DPQC1wzcz6pDVUqA+S3vvvWgvcD/Rxf0Bz5B8Cd3B/Qn3z1ZvFPqAHsEzS7kBpZtt9P5uARUXYT0IXSR+jSjPbBKwF1gCLU9rKxIfUi7Ckekm3JRW1bfKRMxkXBXuj3QDvgLlm1rGYfuIQ9/E9Dns5MI2dLH3IYxc00cuTkr6GCyS9Bc4DHYDRrchpupfXUtbPzIdCpqCsMMjLWwnlt3HRVQWcKQUBM6sBOgHluEV5HO7jb0lpIjMf8hiAci/fJJQH+q4l5FAD9Ay9nwDmS3qWUD+KzHz4Jw9ikiollQGVwEygP3DVzEa0Npc8BiCIjvKE8kD/utREJD2VdAQ3XVQAB1M2zcyHPAbgppdVCeXBTiRpfs0ckh4A14Eh/sT6O2TmQx4DEJwfJpvZT/2bWWdgLO7UeKmVefXy8kuKupn5UNJF2O+X2wGNkj4BSGo0s5O4334JsDvcBHdS3S/pXcRWHTAPWCCprgVcqoCnkt5E9G2AjbhD1YVoCiFLH+KQegDMbAYww79WejnGfxiA55JqIs3O4HIe/Qgdv3GnzQvALjObBNwARuH217eAdTEUgkj7nJZzBNOAzWZ2DrgHvMDthKpxi/ATYGFMuyx9+AWFTEHDcRE4D5jidf1DutlpDUlqxO2/63CkVwIDcPmZ0QlJsaHAW+B4AZzDOA0cALrjdj6rgFnAS1zUDpF0vcQ+/IKy4EImlI42nzD6Y2BmXXERu03S6pzpFA0zawCqk9LRMjPxZ90HjAc+AdvzJtJSxN0HwM9rwH1+5Kshch+QJyQdA9rnzaNIhO8DvuMbaYtJX5Gn7IQAAAAASUVORK5CYII=", - "text/latex": [ - "$\\displaystyle \\left[ 1.0, \\ 3.0\\right]$" - ], - "text/plain": [ - "[1.0, 3.0]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "time_lags" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
V6V5V7V5_lag1V7_lag1V7_lag2V7_lag3
06570000
17685700
28796870
398107987
498781098
\n", - "
" - ], - "text/plain": [ - " V6 V5 V7 V5_lag1 V7_lag1 V7_lag2 V7_lag3\n", - "0 6 5 7 0 0 0 0\n", - "1 7 6 8 5 7 0 0\n", - "2 8 7 9 6 8 7 0\n", - "3 9 8 10 7 9 8 7\n", - "4 9 8 7 8 10 9 8" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "time_shifted_df = shift_columns_by_lag(dataframe,parents,time_lags,filter=True, child_node=target_node)\n", "time_shifted_df.head()" @@ -308,20 +155,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['V7', 'V7_lag1', 'V7_lag2', 'V7_lag3']" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "treatment = 'V7'\n", "# Rename the lagged treatment columns to avoid ambiguity\n", @@ -331,47 +167,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "*** Causal Estimate ***\n", - "\n", - "## Identified estimand\n", - "Estimand type: EstimandType.NONPARAMETRIC_ATE\n", - "\n", - "### Estimand : 1\n", - "Estimand name: backdoor\n", - "Estimand expression:\n", - " d \n", - "───────────────────────────────────(E[V₆])\n", - "d[V₇ V_7_lag1 V_7_lag2 V_7_lag3] \n", - "Estimand assumption 1, Unconfoundedness: If U→{V7,V7_lag1,V7_lag2,V7_lag3} and U→V6 then P(V6|V7,V7_lag1,V7_lag2,V7_lag3,,U) = P(V6|V7,V7_lag1,V7_lag2,V7_lag3,)\n", - "\n", - "## Realized estimand\n", - "b: V6~V7+V7_lag1+V7_lag2+V7_lag3\n", - "Target units: ate\n", - "\n", - "## Estimate\n", - "Mean value: 0.19559790038471547\n", - "p-value: [0.48050704 0.04842794 0.98730841 0.40316486]\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/scipy/stats/_axis_nan_policy.py:531: UserWarning: kurtosistest only valid for n>=20 ... continuing anyway, n=10\n", - " res = hypotest_fun_out(*samples, **kwds)\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n" - ] - } - ], + "outputs": [], "source": [ "# perform causal effect estimation on this new dataset\n", "import dowhy\n", @@ -403,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -420,20 +218,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from tigramite import plotting as tp\n", "tp.plot_timeseries(dataframe, figsize=(15, 5)); plt.show()" @@ -441,7 +228,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -457,26 +244,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "##\n", - "## Running Tigramite BivCI algorithm\n", - "##\n", - "\n", - "Parameters:\n", - "\n", - "independence test = par_corr\n", - "tau_min = 0\n", - "tau_max = 3\n" - ] - } - ], + "outputs": [], "source": [ "correlations = pcmci.run_bivci(tau_max=3, val_only=True)['val_matrix']\n", "matrix_lags = np.argmax(np.abs(correlations), axis=2)" @@ -484,5547 +254,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "##\n", - "## Optimizing pc_alpha over pc_alpha_list = [0.001, 0.005, 0.01, 0.025, 0.05]\n", - "##\n", - "\n", - "## pc_alpha = 0.001 (1/5):\n", - "\n", - "##\n", - "## Step 1: PC1 algorithm for selecting lagged conditions\n", - "##\n", - "\n", - "Parameters:\n", - "independence test = par_corr\n", - "tau_min = 1\n", - "tau_max = 3\n", - "pc_alpha = [0.001]\n", - "max_conds_dim = None\n", - "max_combinations = 1\n", - "\n", - "\n", - "\n", - "## Variable V1\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V1 (1/21):\n", - " Subset 0: () gives pval = 0.76612 / val = -0.234\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V1 (2/21):\n", - " Subset 0: () gives pval = 0.52792 / val = -0.472\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V1 (3/21):\n", - " Subset 0: () gives pval = 0.19791 / val = -0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V1 (4/21):\n", - " Subset 0: () gives pval = 0.07702 / val = 0.923\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V1 (5/21):\n", - " Subset 0: () gives pval = 0.96797 / val = -0.032\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V1 (6/21):\n", - " Subset 0: () gives pval = 0.09642 / val = -0.904\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V1 (7/21):\n", - " Subset 0: () gives pval = 0.44848 / val = -0.552\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V1 (8/21):\n", - " Subset 0: () gives pval = 0.68330 / val = 0.317\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V1 (9/21):\n", - " Subset 0: () gives pval = 0.54066 / val = 0.459\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V1 (10/21):\n", - " Subset 0: () gives pval = 0.29779 / val = -0.702\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V1 (11/21):\n", - " Subset 0: () gives pval = 0.52864 / val = -0.471\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V1 (12/21):\n", - " Subset 0: () gives pval = 0.20579 / val = 0.794\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V1 (13/21):\n", - " Subset 0: () gives pval = 0.39236 / val = 0.608\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V1 (14/21):\n", - " Subset 0: () gives pval = 0.67772 / val = -0.322\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V1 (15/21):\n", - " Subset 0: () gives pval = 0.21445 / val = 0.786\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V1 (16/21):\n", - " Subset 0: () gives pval = 0.07663 / val = -0.923\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V1 (17/21):\n", - " Subset 0: () gives pval = 0.90942 / val = -0.091\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V1 (18/21):\n", - " Subset 0: () gives pval = 0.24793 / val = 0.752\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V1 (19/21):\n", - " Subset 0: () gives pval = 0.95866 / val = 0.041\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V1 (20/21):\n", - " Subset 0: () gives pval = 0.02837 / val = -0.972\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V1 (21/21):\n", - " Subset 0: () gives pval = 0.95338 / val = 0.047\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V1\n", - "\n", - "## Variable V2\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V2 (1/21):\n", - " Subset 0: () gives pval = 0.10887 / val = -0.891\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V2 (2/21):\n", - " Subset 0: () gives pval = 0.95900 / val = -0.041\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V2 (3/21):\n", - " Subset 0: () gives pval = 0.35587 / val = 0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V2 (4/21):\n", - " Subset 0: () gives pval = 0.84212 / val = -0.158\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V2 (5/21):\n", - " Subset 0: () gives pval = 0.02381 / val = -0.976\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V2 (6/21):\n", - " Subset 0: () gives pval = 0.49923 / val = 0.501\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V2 (7/21):\n", - " Subset 0: () gives pval = 0.83019 / val = -0.170\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V2 (8/21):\n", - " Subset 0: () gives pval = 0.14931 / val = 0.851\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V2 (9/21):\n", - " Subset 0: () gives pval = 0.93518 / val = -0.065\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V2 (10/21):\n", - " Subset 0: () gives pval = 0.57191 / val = -0.428\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V2 (11/21):\n", - " Subset 0: () gives pval = 0.05965 / val = 0.940\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V2 (12/21):\n", - " Subset 0: () gives pval = 0.67197 / val = 0.328\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V2 (13/21):\n", - " Subset 0: () gives pval = 0.31401 / val = -0.686\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V2 (14/21):\n", - " Subset 0: () gives pval = 0.38770 / val = 0.612\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V2 (15/21):\n", - " Subset 0: () gives pval = 0.57992 / val = 0.420\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V2 (16/21):\n", - " Subset 0: () gives pval = 0.95332 / val = -0.047\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V2 (17/21):\n", - " Subset 0: () gives pval = 0.00295 / val = 0.997\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V2 (18/21):\n", - " Subset 0: () gives pval = 0.89811 / val = 0.102\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V2 (19/21):\n", - " Subset 0: () gives pval = 0.29986 / val = -0.700\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V2 (20/21):\n", - " Subset 0: () gives pval = 0.92687 / val = 0.073\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V2 (21/21):\n", - " Subset 0: () gives pval = 0.02116 / val = 0.979\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V2\n", - "\n", - "## Variable V3\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V3 (1/21):\n", - " Subset 0: () gives pval = 0.75382 / val = -0.246\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V3 (2/21):\n", - " Subset 0: () gives pval = 0.84711 / val = 0.153\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V3 (3/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V3 (4/21):\n", - " Subset 0: () gives pval = 0.48971 / val = 0.510\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V3 (5/21):\n", - " Subset 0: () gives pval = 0.86516 / val = 0.135\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V3 (6/21):\n", - " Subset 0: () gives pval = 0.37746 / val = -0.623\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V3 (7/21):\n", - " Subset 0: () gives pval = 0.11338 / val = -0.887\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V3 (8/21):\n", - " Subset 0: () gives pval = 0.67814 / val = 0.322\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V3 (9/21):\n", - " Subset 0: () gives pval = 0.83884 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V3 (10/21):\n", - " Subset 0: () gives pval = 0.76348 / val = -0.237\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V3 (11/21):\n", - " Subset 0: () gives pval = 0.59220 / val = -0.408\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V3 (12/21):\n", - " Subset 0: () gives pval = 0.64658 / val = 0.353\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V3 (13/21):\n", - " Subset 0: () gives pval = 0.14720 / val = 0.853\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V3 (14/21):\n", - " Subset 0: () gives pval = 0.23881 / val = -0.761\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V3 (15/21):\n", - " Subset 0: () gives pval = 0.59382 / val = 0.406\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V3 (16/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V3 (17/21):\n", - " Subset 0: () gives pval = 0.80931 / val = -0.191\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V3 (18/21):\n", - " Subset 0: () gives pval = 0.78890 / val = 0.211\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V3 (19/21):\n", - " Subset 0: () gives pval = 0.47777 / val = 0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V3 (20/21):\n", - " Subset 0: () gives pval = 0.36364 / val = -0.636\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V3 (21/21):\n", - " Subset 0: () gives pval = 0.96075 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V3\n", - "\n", - "## Variable V4\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V4 (1/21):\n", - " Subset 0: () gives pval = 0.45446 / val = 0.546\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V4 (2/21):\n", - " Subset 0: () gives pval = 0.63860 / val = 0.361\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V4 (3/21):\n", - " Subset 0: () gives pval = 0.44451 / val = -0.555\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V4 (4/21):\n", - " Subset 0: () gives pval = 0.86082 / val = 0.139\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V4 (5/21):\n", - " Subset 0: () gives pval = 0.16334 / val = 0.837\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V4 (6/21):\n", - " Subset 0: () gives pval = 0.50949 / val = -0.491\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V4 (7/21):\n", - " Subset 0: () gives pval = 0.62576 / val = -0.374\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V4 (8/21):\n", - " Subset 0: () gives pval = 0.51092 / val = -0.489\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V4 (9/21):\n", - " Subset 0: () gives pval = 0.71429 / val = -0.286\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V4 (10/21):\n", - " Subset 0: () gives pval = 0.58069 / val = 0.419\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V4 (11/21):\n", - " Subset 0: () gives pval = 0.18066 / val = -0.819\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V4 (12/21):\n", - " Subset 0: () gives pval = 0.71082 / val = -0.289\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V4 (13/21):\n", - " Subset 0: () gives pval = 0.05509 / val = 0.945\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V4 (14/21):\n", - " Subset 0: () gives pval = 0.06126 / val = -0.939\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V4 (15/21):\n", - " Subset 0: () gives pval = 0.69139 / val = -0.309\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V4 (16/21):\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V4 (17/21):\n", - " Subset 0: () gives pval = 0.15485 / val = -0.845\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V4 (18/21):\n", - " Subset 0: () gives pval = 0.77546 / val = -0.225\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V4 (19/21):\n", - " Subset 0: () gives pval = 0.07418 / val = 0.926\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V4 (20/21):\n", - " Subset 0: () gives pval = 0.83884 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V4 (21/21):\n", - " Subset 0: () gives pval = 0.23452 / val = -0.765\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V4\n", - "\n", - "## Variable V5\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V5 (1/21):\n", - " Subset 0: () gives pval = 0.40591 / val = -0.594\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V5 (2/21):\n", - " Subset 0: () gives pval = 0.22108 / val = 0.779\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V5 (3/21):\n", - " Subset 0: () gives pval = 0.18784 / val = 0.812\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V5 (4/21):\n", - " Subset 0: () gives pval = 0.33692 / val = -0.663\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V5 (5/21):\n", - " Subset 0: () gives pval = 0.56614 / val = -0.434\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V5 (6/21):\n", - " Subset 0: () gives pval = 0.27666 / val = 0.723\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V5 (7/21):\n", - " Subset 0: () gives pval = 0.49057 / val = -0.509\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V5 (8/21):\n", - " Subset 0: () gives pval = 0.44520 / val = 0.555\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V5 (9/21):\n", - " Subset 0: () gives pval = 0.15734 / val = -0.843\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V5 (10/21):\n", - " Subset 0: () gives pval = 0.66704 / val = 0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V5 (11/21):\n", - " Subset 0: () gives pval = 0.27833 / val = 0.722\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V5 (12/21):\n", - " Subset 0: () gives pval = 0.62823 / val = -0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V5 (13/21):\n", - " Subset 0: () gives pval = 0.82850 / val = -0.171\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V5 (14/21):\n", - " Subset 0: () gives pval = 0.86689 / val = -0.133\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V5 (15/21):\n", - " Subset 0: () gives pval = 0.76662 / val = -0.233\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V5 (16/21):\n", - " Subset 0: () gives pval = 0.48656 / val = 0.513\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V5 (17/21):\n", - " Subset 0: () gives pval = 0.46312 / val = 0.537\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V5 (18/21):\n", - " Subset 0: () gives pval = 0.35473 / val = -0.645\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V5 (19/21):\n", - " Subset 0: () gives pval = 0.85997 / val = 0.140\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V5 (20/21):\n", - " Subset 0: () gives pval = 0.48811 / val = 0.512\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V5 (21/21):\n", - " Subset 0: () gives pval = 0.46322 / val = 0.537\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V5\n", - "\n", - "## Variable V6\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V6 (1/21):\n", - " Subset 0: () gives pval = 0.72783 / val = 0.272\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V6 (2/21):\n", - " Subset 0: () gives pval = 0.15485 / val = 0.845\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V6 (3/21):\n", - " Subset 0: () gives pval = 0.96151 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V6 (4/21):\n", - " Subset 0: () gives pval = 0.60943 / val = -0.391\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V6 (5/21):\n", - " Subset 0: () gives pval = 0.40372 / val = 0.596\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V6 (6/21):\n", - " Subset 0: () gives pval = 0.92353 / val = 0.076\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V6 (7/21):\n", - " Subset 0: () gives pval = 0.48656 / val = -0.513\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V6 (8/21):\n", - " Subset 0: () gives pval = 0.74584 / val = -0.254\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V6 (9/21):\n", - " Subset 0: () gives pval = 0.19822 / val = -0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V6 (10/21):\n", - " Subset 0: () gives pval = 0.28091 / val = 0.719\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V6 (11/21):\n", - " Subset 0: () gives pval = 0.66939 / val = -0.331\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V6 (12/21):\n", - " Subset 0: () gives pval = 0.36883 / val = -0.631\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V6 (13/21):\n", - " Subset 0: () gives pval = 0.29289 / val = 0.707\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V6 (14/21):\n", - " Subset 0: () gives pval = 0.08530 / val = -0.915\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V6 (15/21):\n", - " Subset 0: () gives pval = 0.42265 / val = -0.577\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V6 (16/21):\n", - " Subset 0: () gives pval = 0.55095 / val = 0.449\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V6 (17/21):\n", - " Subset 0: () gives pval = 0.47295 / val = -0.527\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V6 (18/21):\n", - " Subset 0: () gives pval = 0.29986 / val = -0.700\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V6 (19/21):\n", - " Subset 0: () gives pval = 0.03775 / val = 0.962\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V6 (20/21):\n", - " Subset 0: () gives pval = 0.69849 / val = 0.302\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V6 (21/21):\n", - " Subset 0: () gives pval = 0.52264 / val = -0.477\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V6\n", - "\n", - "## Variable V7\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V7 (1/21):\n", - " Subset 0: () gives pval = 0.52860 / val = 0.471\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V7 (2/21):\n", - " Subset 0: () gives pval = 0.12169 / val = -0.878\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V7 (3/21):\n", - " Subset 0: () gives pval = 0.26667 / val = -0.733\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V7 (4/21):\n", - " Subset 0: () gives pval = 0.32352 / val = 0.676\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V7 (5/21):\n", - " Subset 0: () gives pval = 0.74180 / val = 0.258\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V7 (6/21):\n", - " Subset 0: () gives pval = 0.33773 / val = -0.662\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V7 (7/21):\n", - " Subset 0: () gives pval = 0.43408 / val = 0.566\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V7 (8/21):\n", - " Subset 0: () gives pval = 0.55977 / val = -0.440\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V7 (9/21):\n", - " Subset 0: () gives pval = 0.07418 / val = 0.926\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V7 (10/21):\n", - " Subset 0: () gives pval = 0.54709 / val = -0.453\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V7 (11/21):\n", - " Subset 0: () gives pval = 0.42736 / val = -0.573\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V7 (12/21):\n", - " Subset 0: () gives pval = 0.53148 / val = 0.469\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V7 (13/21):\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V7 (14/21):\n", - " Subset 0: () gives pval = 0.68314 / val = 0.317\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V7 (15/21):\n", - " Subset 0: () gives pval = 0.66667 / val = 0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V7 (16/21):\n", - " Subset 0: () gives pval = 0.44444 / val = -0.556\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V7 (17/21):\n", - " Subset 0: () gives pval = 0.63485 / val = -0.365\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V7 (18/21):\n", - " Subset 0: () gives pval = 0.27239 / val = 0.728\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V7 (19/21):\n", - " Subset 0: () gives pval = 0.66667 / val = -0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V7 (20/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V7 (21/21):\n", - " Subset 0: () gives pval = 0.62418 / val = -0.376\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V7\n", - "\n", - "## Resulting lagged parent (super)sets:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "##\n", - "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", - "##\n", - "\n", - "Parameters:\n", - "\n", - "independence test = par_corr\n", - "tau_min = 0\n", - "tau_max = 3\n", - "pc_alpha = 0.001\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "reset_lagged_links = False\n", - "max_conds_dim = None\n", - "max_conds_py = None\n", - "max_conds_px = None\n", - "max_conds_px_lagged = None\n", - "fdr_method = none\n", - "\n", - "--------------------------\n", - "Skeleton discovery phase\n", - "--------------------------\n", - "\n", - "Testing contemporaneous condition sets of dimension 0: \n", - "\n", - " Link (V1 0) o?o V2 (1/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.84368 / val = -0.156\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V3 (2/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.20111 / val = 0.799\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V4 (3/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.65550 / val = 0.345\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V5 (4/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.60053 / val = -0.399\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V6 (5/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.92839 / val = -0.072\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V7 (6/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.62790 / val = 0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V1 (7/42):\n", - " Already removed.\n", - "\n", - " Link (V2 0) o?o V3 (8/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.78062 / val = -0.219\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V4 (9/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.15734 / val = -0.843\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V5 (10/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.41176 / val = 0.588\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V6 (11/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.51493 / val = -0.485\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V7 (12/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.57992 / val = -0.420\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V1 (13/42):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V2 (14/42):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V4 (15/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.35534 / val = 0.645\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V5 (16/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.92687 / val = 0.073\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V6 (17/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.49748 / val = 0.503\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V7 (18/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.82592 / val = -0.174\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V1 (19/42):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V2 (20/42):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V3 (21/42):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V5 (22/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.80554 / val = -0.194\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V6 (23/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.19822 / val = 0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V7 (24/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V1 (25/42):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V2 (26/42):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V3 (27/42):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V4 (28/42):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V6 (29/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.59577 / val = 0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V7 (30/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.01980 / val = -0.980\n", - " Non-significance detected.\n", - "\n", - " Link (V6 0) o?o V1 (31/42):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V2 (32/42):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V3 (33/42):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V4 (34/42):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V5 (35/42):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V7 (36/42):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.42265 / val = -0.577\n", - " Non-significance detected.\n", - "\n", - " Link (V7 0) o?o V1 (37/42):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V2 (38/42):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V3 (39/42):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V4 (40/42):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V5 (41/42):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V6 (42/42):\n", - " Already removed.\n", - "\n", - "Updated contemp. adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged at p = 0.\n", - "\n", - "----------------------------\n", - "Collider orientation phase\n", - "----------------------------\n", - "\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "\n", - "----------------------------\n", - "Rule orientation phase\n", - "----------------------------\n", - "\n", - "Try rule(s) [1 2 3]\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## Significant links at alpha = 0.001:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## pc_alpha = 0.005 (2/5):\n", - "\n", - "##\n", - "## Step 1: PC1 algorithm for selecting lagged conditions\n", - "##\n", - "\n", - "Parameters:\n", - "independence test = par_corr\n", - "tau_min = 1\n", - "tau_max = 3\n", - "pc_alpha = [0.005]\n", - "max_conds_dim = None\n", - "max_combinations = 1\n", - "\n", - "\n", - "\n", - "## Variable V1\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V1 (1/21):\n", - " Subset 0: () gives pval = 0.76612 / val = -0.234\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V1 (2/21):\n", - " Subset 0: () gives pval = 0.52792 / val = -0.472\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V1 (3/21):\n", - " Subset 0: () gives pval = 0.19791 / val = -0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V1 (4/21):\n", - " Subset 0: () gives pval = 0.07702 / val = 0.923\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V1 (5/21):\n", - " Subset 0: () gives pval = 0.96797 / val = -0.032\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V1 (6/21):\n", - " Subset 0: () gives pval = 0.09642 / val = -0.904\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V1 (7/21):\n", - " Subset 0: () gives pval = 0.44848 / val = -0.552\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V1 (8/21):\n", - " Subset 0: () gives pval = 0.68330 / val = 0.317\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V1 (9/21):\n", - " Subset 0: () gives pval = 0.54066 / val = 0.459\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V1 (10/21):\n", - " Subset 0: () gives pval = 0.29779 / val = -0.702\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V1 (11/21):\n", - " Subset 0: () gives pval = 0.52864 / val = -0.471\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V1 (12/21):\n", - " Subset 0: () gives pval = 0.20579 / val = 0.794\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V1 (13/21):\n", - " Subset 0: () gives pval = 0.39236 / val = 0.608\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V1 (14/21):\n", - " Subset 0: () gives pval = 0.67772 / val = -0.322\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V1 (15/21):\n", - " Subset 0: () gives pval = 0.21445 / val = 0.786\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V1 (16/21):\n", - " Subset 0: () gives pval = 0.07663 / val = -0.923\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V1 (17/21):\n", - " Subset 0: () gives pval = 0.90942 / val = -0.091\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V1 (18/21):\n", - " Subset 0: () gives pval = 0.24793 / val = 0.752\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V1 (19/21):\n", - " Subset 0: () gives pval = 0.95866 / val = 0.041\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V1 (20/21):\n", - " Subset 0: () gives pval = 0.02837 / val = -0.972\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V1 (21/21):\n", - " Subset 0: () gives pval = 0.95338 / val = 0.047\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V1\n", - "\n", - "## Variable V2\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V2 (1/21):\n", - " Subset 0: () gives pval = 0.10887 / val = -0.891\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V2 (2/21):\n", - " Subset 0: () gives pval = 0.95900 / val = -0.041\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V2 (3/21):\n", - " Subset 0: () gives pval = 0.35587 / val = 0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V2 (4/21):\n", - " Subset 0: () gives pval = 0.84212 / val = -0.158\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V2 (5/21):\n", - " Subset 0: () gives pval = 0.02381 / val = -0.976\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V2 (6/21):\n", - " Subset 0: () gives pval = 0.49923 / val = 0.501\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V2 (7/21):\n", - " Subset 0: () gives pval = 0.83019 / val = -0.170\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V2 (8/21):\n", - " Subset 0: () gives pval = 0.14931 / val = 0.851\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V2 (9/21):\n", - " Subset 0: () gives pval = 0.93518 / val = -0.065\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V2 (10/21):\n", - " Subset 0: () gives pval = 0.57191 / val = -0.428\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V2 (11/21):\n", - " Subset 0: () gives pval = 0.05965 / val = 0.940\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V2 (12/21):\n", - " Subset 0: () gives pval = 0.67197 / val = 0.328\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V2 (13/21):\n", - " Subset 0: () gives pval = 0.31401 / val = -0.686\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V2 (14/21):\n", - " Subset 0: () gives pval = 0.38770 / val = 0.612\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V2 (15/21):\n", - " Subset 0: () gives pval = 0.57992 / val = 0.420\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V2 (16/21):\n", - " Subset 0: () gives pval = 0.95332 / val = -0.047\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V2 (17/21):\n", - " Subset 0: () gives pval = 0.00295 / val = 0.997\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V6 -3) -?> V2 (18/21):\n", - " Subset 0: () gives pval = 0.89811 / val = 0.102\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V2 (19/21):\n", - " Subset 0: () gives pval = 0.29986 / val = -0.700\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V2 (20/21):\n", - " Subset 0: () gives pval = 0.92687 / val = 0.073\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V2 (21/21):\n", - " Subset 0: () gives pval = 0.02116 / val = 0.979\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V6 -2): max_pval = 0.00295, |min_val| = 0.997\n", - "\n", - "Algorithm converged for variable V2\n", - "\n", - "## Variable V3\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V3 (1/21):\n", - " Subset 0: () gives pval = 0.75382 / val = -0.246\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V3 (2/21):\n", - " Subset 0: () gives pval = 0.84711 / val = 0.153\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V3 (3/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V3 (4/21):\n", - " Subset 0: () gives pval = 0.48971 / val = 0.510\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V3 (5/21):\n", - " Subset 0: () gives pval = 0.86516 / val = 0.135\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V3 (6/21):\n", - " Subset 0: () gives pval = 0.37746 / val = -0.623\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V3 (7/21):\n", - " Subset 0: () gives pval = 0.11338 / val = -0.887\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V3 (8/21):\n", - " Subset 0: () gives pval = 0.67814 / val = 0.322\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V3 (9/21):\n", - " Subset 0: () gives pval = 0.83884 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V3 (10/21):\n", - " Subset 0: () gives pval = 0.76348 / val = -0.237\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V3 (11/21):\n", - " Subset 0: () gives pval = 0.59220 / val = -0.408\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V3 (12/21):\n", - " Subset 0: () gives pval = 0.64658 / val = 0.353\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V3 (13/21):\n", - " Subset 0: () gives pval = 0.14720 / val = 0.853\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V3 (14/21):\n", - " Subset 0: () gives pval = 0.23881 / val = -0.761\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V3 (15/21):\n", - " Subset 0: () gives pval = 0.59382 / val = 0.406\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V3 (16/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V3 (17/21):\n", - " Subset 0: () gives pval = 0.80931 / val = -0.191\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V3 (18/21):\n", - " Subset 0: () gives pval = 0.78890 / val = 0.211\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V3 (19/21):\n", - " Subset 0: () gives pval = 0.47777 / val = 0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V3 (20/21):\n", - " Subset 0: () gives pval = 0.36364 / val = -0.636\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V3 (21/21):\n", - " Subset 0: () gives pval = 0.96075 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V3\n", - "\n", - "## Variable V4\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V4 (1/21):\n", - " Subset 0: () gives pval = 0.45446 / val = 0.546\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V4 (2/21):\n", - " Subset 0: () gives pval = 0.63860 / val = 0.361\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V4 (3/21):\n", - " Subset 0: () gives pval = 0.44451 / val = -0.555\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V4 (4/21):\n", - " Subset 0: () gives pval = 0.86082 / val = 0.139\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V4 (5/21):\n", - " Subset 0: () gives pval = 0.16334 / val = 0.837\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V4 (6/21):\n", - " Subset 0: () gives pval = 0.50949 / val = -0.491\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V4 (7/21):\n", - " Subset 0: () gives pval = 0.62576 / val = -0.374\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V4 (8/21):\n", - " Subset 0: () gives pval = 0.51092 / val = -0.489\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V4 (9/21):\n", - " Subset 0: () gives pval = 0.71429 / val = -0.286\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V4 (10/21):\n", - " Subset 0: () gives pval = 0.58069 / val = 0.419\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V4 (11/21):\n", - " Subset 0: () gives pval = 0.18066 / val = -0.819\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V4 (12/21):\n", - " Subset 0: () gives pval = 0.71082 / val = -0.289\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V4 (13/21):\n", - " Subset 0: () gives pval = 0.05509 / val = 0.945\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V4 (14/21):\n", - " Subset 0: () gives pval = 0.06126 / val = -0.939\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V4 (15/21):\n", - " Subset 0: () gives pval = 0.69139 / val = -0.309\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V4 (16/21):\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V4 (17/21):\n", - " Subset 0: () gives pval = 0.15485 / val = -0.845\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V4 (18/21):\n", - " Subset 0: () gives pval = 0.77546 / val = -0.225\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V4 (19/21):\n", - " Subset 0: () gives pval = 0.07418 / val = 0.926\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V4 (20/21):\n", - " Subset 0: () gives pval = 0.83884 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V4 (21/21):\n", - " Subset 0: () gives pval = 0.23452 / val = -0.765\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V4\n", - "\n", - "## Variable V5\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V5 (1/21):\n", - " Subset 0: () gives pval = 0.40591 / val = -0.594\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V5 (2/21):\n", - " Subset 0: () gives pval = 0.22108 / val = 0.779\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V5 (3/21):\n", - " Subset 0: () gives pval = 0.18784 / val = 0.812\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V5 (4/21):\n", - " Subset 0: () gives pval = 0.33692 / val = -0.663\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V5 (5/21):\n", - " Subset 0: () gives pval = 0.56614 / val = -0.434\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V5 (6/21):\n", - " Subset 0: () gives pval = 0.27666 / val = 0.723\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V5 (7/21):\n", - " Subset 0: () gives pval = 0.49057 / val = -0.509\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V5 (8/21):\n", - " Subset 0: () gives pval = 0.44520 / val = 0.555\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V5 (9/21):\n", - " Subset 0: () gives pval = 0.15734 / val = -0.843\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V5 (10/21):\n", - " Subset 0: () gives pval = 0.66704 / val = 0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V5 (11/21):\n", - " Subset 0: () gives pval = 0.27833 / val = 0.722\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V5 (12/21):\n", - " Subset 0: () gives pval = 0.62823 / val = -0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V5 (13/21):\n", - " Subset 0: () gives pval = 0.82850 / val = -0.171\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V5 (14/21):\n", - " Subset 0: () gives pval = 0.86689 / val = -0.133\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V5 (15/21):\n", - " Subset 0: () gives pval = 0.76662 / val = -0.233\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V5 (16/21):\n", - " Subset 0: () gives pval = 0.48656 / val = 0.513\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V5 (17/21):\n", - " Subset 0: () gives pval = 0.46312 / val = 0.537\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V5 (18/21):\n", - " Subset 0: () gives pval = 0.35473 / val = -0.645\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V5 (19/21):\n", - " Subset 0: () gives pval = 0.85997 / val = 0.140\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V5 (20/21):\n", - " Subset 0: () gives pval = 0.48811 / val = 0.512\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V5 (21/21):\n", - " Subset 0: () gives pval = 0.46322 / val = 0.537\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V5\n", - "\n", - "## Variable V6\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V6 (1/21):\n", - " Subset 0: () gives pval = 0.72783 / val = 0.272\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V6 (2/21):\n", - " Subset 0: () gives pval = 0.15485 / val = 0.845\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V6 (3/21):\n", - " Subset 0: () gives pval = 0.96151 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V6 (4/21):\n", - " Subset 0: () gives pval = 0.60943 / val = -0.391\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V6 (5/21):\n", - " Subset 0: () gives pval = 0.40372 / val = 0.596\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V6 (6/21):\n", - " Subset 0: () gives pval = 0.92353 / val = 0.076\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V6 (7/21):\n", - " Subset 0: () gives pval = 0.48656 / val = -0.513\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V6 (8/21):\n", - " Subset 0: () gives pval = 0.74584 / val = -0.254\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V6 (9/21):\n", - " Subset 0: () gives pval = 0.19822 / val = -0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V6 (10/21):\n", - " Subset 0: () gives pval = 0.28091 / val = 0.719\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V6 (11/21):\n", - " Subset 0: () gives pval = 0.66939 / val = -0.331\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V6 (12/21):\n", - " Subset 0: () gives pval = 0.36883 / val = -0.631\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V6 (13/21):\n", - " Subset 0: () gives pval = 0.29289 / val = 0.707\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V6 (14/21):\n", - " Subset 0: () gives pval = 0.08530 / val = -0.915\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V6 (15/21):\n", - " Subset 0: () gives pval = 0.42265 / val = -0.577\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V6 (16/21):\n", - " Subset 0: () gives pval = 0.55095 / val = 0.449\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V6 (17/21):\n", - " Subset 0: () gives pval = 0.47295 / val = -0.527\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V6 (18/21):\n", - " Subset 0: () gives pval = 0.29986 / val = -0.700\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V6 (19/21):\n", - " Subset 0: () gives pval = 0.03775 / val = 0.962\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V6 (20/21):\n", - " Subset 0: () gives pval = 0.69849 / val = 0.302\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V6 (21/21):\n", - " Subset 0: () gives pval = 0.52264 / val = -0.477\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V6\n", - "\n", - "## Variable V7\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V7 (1/21):\n", - " Subset 0: () gives pval = 0.52860 / val = 0.471\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V7 (2/21):\n", - " Subset 0: () gives pval = 0.12169 / val = -0.878\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V7 (3/21):\n", - " Subset 0: () gives pval = 0.26667 / val = -0.733\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V7 (4/21):\n", - " Subset 0: () gives pval = 0.32352 / val = 0.676\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V7 (5/21):\n", - " Subset 0: () gives pval = 0.74180 / val = 0.258\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V7 (6/21):\n", - " Subset 0: () gives pval = 0.33773 / val = -0.662\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V7 (7/21):\n", - " Subset 0: () gives pval = 0.43408 / val = 0.566\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V7 (8/21):\n", - " Subset 0: () gives pval = 0.55977 / val = -0.440\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V7 (9/21):\n", - " Subset 0: () gives pval = 0.07418 / val = 0.926\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V7 (10/21):\n", - " Subset 0: () gives pval = 0.54709 / val = -0.453\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V7 (11/21):\n", - " Subset 0: () gives pval = 0.42736 / val = -0.573\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V7 (12/21):\n", - " Subset 0: () gives pval = 0.53148 / val = 0.469\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V7 (13/21):\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V7 (14/21):\n", - " Subset 0: () gives pval = 0.68314 / val = 0.317\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V7 (15/21):\n", - " Subset 0: () gives pval = 0.66667 / val = 0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V7 (16/21):\n", - " Subset 0: () gives pval = 0.44444 / val = -0.556\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V7 (17/21):\n", - " Subset 0: () gives pval = 0.63485 / val = -0.365\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V7 (18/21):\n", - " Subset 0: () gives pval = 0.27239 / val = 0.728\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V7 (19/21):\n", - " Subset 0: () gives pval = 0.66667 / val = -0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V7 (20/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V7 (21/21):\n", - " Subset 0: () gives pval = 0.62418 / val = -0.376\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V7\n", - "\n", - "## Resulting lagged parent (super)sets:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V6 -2): max_pval = 0.00295, |min_val| = 0.997\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "##\n", - "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", - "##\n", - "\n", - "Parameters:\n", - "\n", - "independence test = par_corr\n", - "tau_min = 0\n", - "tau_max = 3\n", - "pc_alpha = 0.005\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "reset_lagged_links = False\n", - "max_conds_dim = None\n", - "max_conds_py = None\n", - "max_conds_px = None\n", - "max_conds_px_lagged = None\n", - "fdr_method = none\n", - "\n", - "--------------------------\n", - "Skeleton discovery phase\n", - "--------------------------\n", - "\n", - "Testing contemporaneous condition sets of dimension 0: \n", - "\n", - " Link (V1 0) o?o V2 (1/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V6 -2) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.33580 / val = -0.864\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V3 (2/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.20111 / val = 0.799\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V4 (3/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.65550 / val = 0.345\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V5 (4/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.60053 / val = -0.399\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V6 (5/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.92839 / val = -0.072\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V7 (6/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.62790 / val = 0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V1 (7/43):\n", - " Already removed.\n", - "\n", - " Link (V2 0) o?o V3 (8/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V6 -2) ]\n", - " Subset 0: () gives pval = 0.74598 / val = -0.389\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V4 (9/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V6 -2) ]\n", - " Subset 0: () gives pval = 1.00000 / val = -0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V5 (10/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V6 -2) ]\n", - " Subset 0: () gives pval = 0.38996 / val = 0.818\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V6 (11/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V6 -2) ]\n", - " Subset 0: () gives pval = 0.57412 / val = 0.620\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V7 (12/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V6 -2) ]\n", - " Subset 0: () gives pval = 0.42588 / val = -0.784\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V1 (13/43):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V2 (14/43):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V4 (15/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.35534 / val = 0.645\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V5 (16/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.92687 / val = 0.073\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V6 (17/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.49748 / val = 0.503\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V7 (18/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.82592 / val = -0.174\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V1 (19/43):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V2 (20/43):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V3 (21/43):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V5 (22/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.80554 / val = -0.194\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V6 (23/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.19822 / val = 0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V7 (24/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V1 (25/43):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V2 (26/43):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V3 (27/43):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V4 (28/43):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V6 (29/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.59577 / val = 0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V7 (30/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.01980 / val = -0.980\n", - " Non-significance detected.\n", - "\n", - " Link (V6 0) o?o V1 (31/43):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V2 (32/43):\n", - " Already removed.\n", - "\n", - " Link (V6 -2) -?> V2 (33/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.00295 / val = 0.997\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V6 0) o?o V3 (34/43):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V4 (35/43):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V5 (36/43):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V7 (37/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.42265 / val = -0.577\n", - " Non-significance detected.\n", - "\n", - " Link (V7 0) o?o V1 (38/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V2 (39/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V3 (40/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V4 (41/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V5 (42/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V6 (43/43):\n", - " Already removed.\n", - "\n", - "Updated contemp. adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged at p = 0.\n", - "\n", - "----------------------------\n", - "Collider orientation phase\n", - "----------------------------\n", - "\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V6 -2)\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "\n", - "----------------------------\n", - "Rule orientation phase\n", - "----------------------------\n", - "\n", - "Try rule(s) [1 2 3]\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V6 -2)\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## Significant links at alpha = 0.005:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V6 -2): pval = 0.00295 | val = 0.997\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## pc_alpha = 0.01 (3/5):\n", - "\n", - "##\n", - "## Step 1: PC1 algorithm for selecting lagged conditions\n", - "##\n", - "\n", - "Parameters:\n", - "independence test = par_corr\n", - "tau_min = 1\n", - "tau_max = 3\n", - "pc_alpha = [0.01]\n", - "max_conds_dim = None\n", - "max_combinations = 1\n", - "\n", - "\n", - "\n", - "## Variable V1\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V1 (1/21):\n", - " Subset 0: () gives pval = 0.76612 / val = -0.234\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V1 (2/21):\n", - " Subset 0: () gives pval = 0.52792 / val = -0.472\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V1 (3/21):\n", - " Subset 0: () gives pval = 0.19791 / val = -0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V1 (4/21):\n", - " Subset 0: () gives pval = 0.07702 / val = 0.923\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V1 (5/21):\n", - " Subset 0: () gives pval = 0.96797 / val = -0.032\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V1 (6/21):\n", - " Subset 0: () gives pval = 0.09642 / val = -0.904\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V1 (7/21):\n", - " Subset 0: () gives pval = 0.44848 / val = -0.552\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V1 (8/21):\n", - " Subset 0: () gives pval = 0.68330 / val = 0.317\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V1 (9/21):\n", - " Subset 0: () gives pval = 0.54066 / val = 0.459\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V1 (10/21):\n", - " Subset 0: () gives pval = 0.29779 / val = -0.702\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V1 (11/21):\n", - " Subset 0: () gives pval = 0.52864 / val = -0.471\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V1 (12/21):\n", - " Subset 0: () gives pval = 0.20579 / val = 0.794\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V1 (13/21):\n", - " Subset 0: () gives pval = 0.39236 / val = 0.608\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V1 (14/21):\n", - " Subset 0: () gives pval = 0.67772 / val = -0.322\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V1 (15/21):\n", - " Subset 0: () gives pval = 0.21445 / val = 0.786\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V1 (16/21):\n", - " Subset 0: () gives pval = 0.07663 / val = -0.923\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V1 (17/21):\n", - " Subset 0: () gives pval = 0.90942 / val = -0.091\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V1 (18/21):\n", - " Subset 0: () gives pval = 0.24793 / val = 0.752\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V1 (19/21):\n", - " Subset 0: () gives pval = 0.95866 / val = 0.041\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V1 (20/21):\n", - " Subset 0: () gives pval = 0.02837 / val = -0.972\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V1 (21/21):\n", - " Subset 0: () gives pval = 0.95338 / val = 0.047\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V1\n", - "\n", - "## Variable V2\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V2 (1/21):\n", - " Subset 0: () gives pval = 0.10887 / val = -0.891\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V2 (2/21):\n", - " Subset 0: () gives pval = 0.95900 / val = -0.041\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V2 (3/21):\n", - " Subset 0: () gives pval = 0.35587 / val = 0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V2 (4/21):\n", - " Subset 0: () gives pval = 0.84212 / val = -0.158\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V2 (5/21):\n", - " Subset 0: () gives pval = 0.02381 / val = -0.976\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V2 (6/21):\n", - " Subset 0: () gives pval = 0.49923 / val = 0.501\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V2 (7/21):\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Subset 0: () gives pval = 0.83019 / val = -0.170\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V2 (8/21):\n", - " Subset 0: () gives pval = 0.14931 / val = 0.851\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V2 (9/21):\n", - " Subset 0: () gives pval = 0.93518 / val = -0.065\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V2 (10/21):\n", - " Subset 0: () gives pval = 0.57191 / val = -0.428\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V2 (11/21):\n", - " Subset 0: () gives pval = 0.05965 / val = 0.940\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V2 (12/21):\n", - " Subset 0: () gives pval = 0.67197 / val = 0.328\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V2 (13/21):\n", - " Subset 0: () gives pval = 0.31401 / val = -0.686\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V2 (14/21):\n", - " Subset 0: () gives pval = 0.38770 / val = 0.612\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V2 (15/21):\n", - " Subset 0: () gives pval = 0.57992 / val = 0.420\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V2 (16/21):\n", - " Subset 0: () gives pval = 0.95332 / val = -0.047\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V2 (17/21):\n", - " Subset 0: () gives pval = 0.00295 / val = 0.997\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V6 -3) -?> V2 (18/21):\n", - " Subset 0: () gives pval = 0.89811 / val = 0.102\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V2 (19/21):\n", - " Subset 0: () gives pval = 0.29986 / val = -0.700\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V2 (20/21):\n", - " Subset 0: () gives pval = 0.92687 / val = 0.073\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V2 (21/21):\n", - " Subset 0: () gives pval = 0.02116 / val = 0.979\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V6 -2): max_pval = 0.00295, |min_val| = 0.997\n", - "\n", - "Algorithm converged for variable V2\n", - "\n", - "## Variable V3\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V3 (1/21):\n", - " Subset 0: () gives pval = 0.75382 / val = -0.246\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V3 (2/21):\n", - " Subset 0: () gives pval = 0.84711 / val = 0.153\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V3 (3/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V3 (4/21):\n", - " Subset 0: () gives pval = 0.48971 / val = 0.510\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V3 (5/21):\n", - " Subset 0: () gives pval = 0.86516 / val = 0.135\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V3 (6/21):\n", - " Subset 0: () gives pval = 0.37746 / val = -0.623\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V3 (7/21):\n", - " Subset 0: () gives pval = 0.11338 / val = -0.887\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V3 (8/21):\n", - " Subset 0: () gives pval = 0.67814 / val = 0.322\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V3 (9/21):\n", - " Subset 0: () gives pval = 0.83884 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V3 (10/21):\n", - " Subset 0: () gives pval = 0.76348 / val = -0.237\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V3 (11/21):\n", - " Subset 0: () gives pval = 0.59220 / val = -0.408\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V3 (12/21):\n", - " Subset 0: () gives pval = 0.64658 / val = 0.353\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V3 (13/21):\n", - " Subset 0: () gives pval = 0.14720 / val = 0.853\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V3 (14/21):\n", - " Subset 0: () gives pval = 0.23881 / val = -0.761\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V3 (15/21):\n", - " Subset 0: () gives pval = 0.59382 / val = 0.406\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V3 (16/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V3 (17/21):\n", - " Subset 0: () gives pval = 0.80931 / val = -0.191\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V3 (18/21):\n", - " Subset 0: () gives pval = 0.78890 / val = 0.211\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V3 (19/21):\n", - " Subset 0: () gives pval = 0.47777 / val = 0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V3 (20/21):\n", - " Subset 0: () gives pval = 0.36364 / val = -0.636\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V3 (21/21):\n", - " Subset 0: () gives pval = 0.96075 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V3\n", - "\n", - "## Variable V4\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V4 (1/21):\n", - " Subset 0: () gives pval = 0.45446 / val = 0.546\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V4 (2/21):\n", - " Subset 0: () gives pval = 0.63860 / val = 0.361\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V4 (3/21):\n", - " Subset 0: () gives pval = 0.44451 / val = -0.555\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V4 (4/21):\n", - " Subset 0: () gives pval = 0.86082 / val = 0.139\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V4 (5/21):\n", - " Subset 0: () gives pval = 0.16334 / val = 0.837\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V4 (6/21):\n", - " Subset 0: () gives pval = 0.50949 / val = -0.491\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V4 (7/21):\n", - " Subset 0: () gives pval = 0.62576 / val = -0.374\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V4 (8/21):\n", - " Subset 0: () gives pval = 0.51092 / val = -0.489\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V4 (9/21):\n", - " Subset 0: () gives pval = 0.71429 / val = -0.286\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V4 (10/21):\n", - " Subset 0: () gives pval = 0.58069 / val = 0.419\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V4 (11/21):\n", - " Subset 0: () gives pval = 0.18066 / val = -0.819\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V4 (12/21):\n", - " Subset 0: () gives pval = 0.71082 / val = -0.289\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V4 (13/21):\n", - " Subset 0: () gives pval = 0.05509 / val = 0.945\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V4 (14/21):\n", - " Subset 0: () gives pval = 0.06126 / val = -0.939\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V4 (15/21):\n", - " Subset 0: () gives pval = 0.69139 / val = -0.309\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V4 (16/21):\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V4 (17/21):\n", - " Subset 0: () gives pval = 0.15485 / val = -0.845\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V4 (18/21):\n", - " Subset 0: () gives pval = 0.77546 / val = -0.225\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V4 (19/21):\n", - " Subset 0: () gives pval = 0.07418 / val = 0.926\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V4 (20/21):\n", - " Subset 0: () gives pval = 0.83884 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V4 (21/21):\n", - " Subset 0: () gives pval = 0.23452 / val = -0.765\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V4\n", - "\n", - "## Variable V5\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V5 (1/21):\n", - " Subset 0: () gives pval = 0.40591 / val = -0.594\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V5 (2/21):\n", - " Subset 0: () gives pval = 0.22108 / val = 0.779\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V5 (3/21):\n", - " Subset 0: () gives pval = 0.18784 / val = 0.812\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V5 (4/21):\n", - " Subset 0: () gives pval = 0.33692 / val = -0.663\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V5 (5/21):\n", - " Subset 0: () gives pval = 0.56614 / val = -0.434\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V5 (6/21):\n", - " Subset 0: () gives pval = 0.27666 / val = 0.723\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V5 (7/21):\n", - " Subset 0: () gives pval = 0.49057 / val = -0.509\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V5 (8/21):\n", - " Subset 0: () gives pval = 0.44520 / val = 0.555\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V5 (9/21):\n", - " Subset 0: () gives pval = 0.15734 / val = -0.843\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V5 (10/21):\n", - " Subset 0: () gives pval = 0.66704 / val = 0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V5 (11/21):\n", - " Subset 0: () gives pval = 0.27833 / val = 0.722\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V5 (12/21):\n", - " Subset 0: () gives pval = 0.62823 / val = -0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V5 (13/21):\n", - " Subset 0: () gives pval = 0.82850 / val = -0.171\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V5 (14/21):\n", - " Subset 0: () gives pval = 0.86689 / val = -0.133\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V5 (15/21):\n", - " Subset 0: () gives pval = 0.76662 / val = -0.233\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V5 (16/21):\n", - " Subset 0: () gives pval = 0.48656 / val = 0.513\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V5 (17/21):\n", - " Subset 0: () gives pval = 0.46312 / val = 0.537\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V5 (18/21):\n", - " Subset 0: () gives pval = 0.35473 / val = -0.645\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V5 (19/21):\n", - " Subset 0: () gives pval = 0.85997 / val = 0.140\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V5 (20/21):\n", - " Subset 0: () gives pval = 0.48811 / val = 0.512\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V5 (21/21):\n", - " Subset 0: () gives pval = 0.46322 / val = 0.537\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V5\n", - "\n", - "## Variable V6\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V6 (1/21):\n", - " Subset 0: () gives pval = 0.72783 / val = 0.272\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V6 (2/21):\n", - " Subset 0: () gives pval = 0.15485 / val = 0.845\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V6 (3/21):\n", - " Subset 0: () gives pval = 0.96151 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V6 (4/21):\n", - " Subset 0: () gives pval = 0.60943 / val = -0.391\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V6 (5/21):\n", - " Subset 0: () gives pval = 0.40372 / val = 0.596\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V6 (6/21):\n", - " Subset 0: () gives pval = 0.92353 / val = 0.076\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V6 (7/21):\n", - " Subset 0: () gives pval = 0.48656 / val = -0.513\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V6 (8/21):\n", - " Subset 0: () gives pval = 0.74584 / val = -0.254\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V6 (9/21):\n", - " Subset 0: () gives pval = 0.19822 / val = -0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V6 (10/21):\n", - " Subset 0: () gives pval = 0.28091 / val = 0.719\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V6 (11/21):\n", - " Subset 0: () gives pval = 0.66939 / val = -0.331\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V6 (12/21):\n", - " Subset 0: () gives pval = 0.36883 / val = -0.631\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V6 (13/21):\n", - " Subset 0: () gives pval = 0.29289 / val = 0.707\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V6 (14/21):\n", - " Subset 0: () gives pval = 0.08530 / val = -0.915\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V6 (15/21):\n", - " Subset 0: () gives pval = 0.42265 / val = -0.577\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V6 (16/21):\n", - " Subset 0: () gives pval = 0.55095 / val = 0.449\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V6 (17/21):\n", - " Subset 0: () gives pval = 0.47295 / val = -0.527\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V6 (18/21):\n", - " Subset 0: () gives pval = 0.29986 / val = -0.700\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V6 (19/21):\n", - " Subset 0: () gives pval = 0.03775 / val = 0.962\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V6 (20/21):\n", - " Subset 0: () gives pval = 0.69849 / val = 0.302\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V6 (21/21):\n", - " Subset 0: () gives pval = 0.52264 / val = -0.477\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V6\n", - "\n", - "## Variable V7\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V7 (1/21):\n", - " Subset 0: () gives pval = 0.52860 / val = 0.471\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V7 (2/21):\n", - " Subset 0: () gives pval = 0.12169 / val = -0.878\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V7 (3/21):\n", - " Subset 0: () gives pval = 0.26667 / val = -0.733\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V7 (4/21):\n", - " Subset 0: () gives pval = 0.32352 / val = 0.676\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V7 (5/21):\n", - " Subset 0: () gives pval = 0.74180 / val = 0.258\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V7 (6/21):\n", - " Subset 0: () gives pval = 0.33773 / val = -0.662\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V7 (7/21):\n", - " Subset 0: () gives pval = 0.43408 / val = 0.566\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V7 (8/21):\n", - " Subset 0: () gives pval = 0.55977 / val = -0.440\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V7 (9/21):\n", - " Subset 0: () gives pval = 0.07418 / val = 0.926\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V7 (10/21):\n", - " Subset 0: () gives pval = 0.54709 / val = -0.453\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V7 (11/21):\n", - " Subset 0: () gives pval = 0.42736 / val = -0.573\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V7 (12/21):\n", - " Subset 0: () gives pval = 0.53148 / val = 0.469\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V7 (13/21):\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V7 (14/21):\n", - " Subset 0: () gives pval = 0.68314 / val = 0.317\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V7 (15/21):\n", - " Subset 0: () gives pval = 0.66667 / val = 0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V7 (16/21):\n", - " Subset 0: () gives pval = 0.44444 / val = -0.556\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V7 (17/21):\n", - " Subset 0: () gives pval = 0.63485 / val = -0.365\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V7 (18/21):\n", - " Subset 0: () gives pval = 0.27239 / val = 0.728\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V7 (19/21):\n", - " Subset 0: () gives pval = 0.66667 / val = -0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V7 (20/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V7 (21/21):\n", - " Subset 0: () gives pval = 0.62418 / val = -0.376\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V7\n", - "\n", - "## Resulting lagged parent (super)sets:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V6 -2): max_pval = 0.00295, |min_val| = 0.997\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "##\n", - "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", - "##\n", - "\n", - "Parameters:\n", - "\n", - "independence test = par_corr\n", - "tau_min = 0\n", - "tau_max = 3\n", - "pc_alpha = 0.01\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "reset_lagged_links = False\n", - "max_conds_dim = None\n", - "max_conds_py = None\n", - "max_conds_px = None\n", - "max_conds_px_lagged = None\n", - "fdr_method = none\n", - "\n", - "--------------------------\n", - "Skeleton discovery phase\n", - "--------------------------\n", - "\n", - "Testing contemporaneous condition sets of dimension 0: \n", - "\n", - " Link (V1 0) o?o V2 (1/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V6 -2) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.33580 / val = -0.864\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V3 (2/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.20111 / val = 0.799\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V4 (3/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.65550 / val = 0.345\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V5 (4/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.60053 / val = -0.399\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V6 (5/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.92839 / val = -0.072\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V7 (6/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.62790 / val = 0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V1 (7/43):\n", - " Already removed.\n", - "\n", - " Link (V2 0) o?o V3 (8/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V6 -2) ]\n", - " Subset 0: () gives pval = 0.74598 / val = -0.389\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V4 (9/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V6 -2) ]\n", - " Subset 0: () gives pval = 1.00000 / val = -0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V5 (10/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V6 -2) ]\n", - " Subset 0: () gives pval = 0.38996 / val = 0.818\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V6 (11/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V6 -2) ]\n", - " Subset 0: () gives pval = 0.57412 / val = 0.620\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V7 (12/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V6 -2) ]\n", - " Subset 0: () gives pval = 0.42588 / val = -0.784\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V1 (13/43):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V2 (14/43):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V4 (15/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.35534 / val = 0.645\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V5 (16/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.92687 / val = 0.073\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V6 (17/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.49748 / val = 0.503\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V7 (18/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.82592 / val = -0.174\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V1 (19/43):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V2 (20/43):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V3 (21/43):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V5 (22/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.80554 / val = -0.194\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V6 (23/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.19822 / val = 0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V7 (24/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V1 (25/43):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V2 (26/43):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V3 (27/43):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V4 (28/43):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V6 (29/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.59577 / val = 0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V7 (30/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.01980 / val = -0.980\n", - " Non-significance detected.\n", - "\n", - " Link (V6 0) o?o V1 (31/43):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V2 (32/43):\n", - " Already removed.\n", - "\n", - " Link (V6 -2) -?> V2 (33/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.00295 / val = 0.997\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V6 0) o?o V3 (34/43):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V4 (35/43):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V5 (36/43):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V7 (37/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.42265 / val = -0.577\n", - " Non-significance detected.\n", - "\n", - " Link (V7 0) o?o V1 (38/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V2 (39/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V3 (40/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V4 (41/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V5 (42/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V6 (43/43):\n", - " Already removed.\n", - "\n", - "Updated contemp. adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged at p = 0.\n", - "\n", - "----------------------------\n", - "Collider orientation phase\n", - "----------------------------\n", - "\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V6 -2)\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "\n", - "----------------------------\n", - "Rule orientation phase\n", - "----------------------------\n", - "\n", - "Try rule(s) [1 2 3]\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V6 -2)\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## Significant links at alpha = 0.01:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V6 -2): pval = 0.00295 | val = 0.997\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## pc_alpha = 0.025 (4/5):\n", - "\n", - "##\n", - "## Step 1: PC1 algorithm for selecting lagged conditions\n", - "##\n", - "\n", - "Parameters:\n", - "independence test = par_corr\n", - "tau_min = 1\n", - "tau_max = 3\n", - "pc_alpha = [0.025]\n", - "max_conds_dim = None\n", - "max_combinations = 1\n", - "\n", - "\n", - "\n", - "## Variable V1\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V1 (1/21):\n", - " Subset 0: () gives pval = 0.76612 / val = -0.234\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V1 (2/21):\n", - " Subset 0: () gives pval = 0.52792 / val = -0.472\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V1 (3/21):\n", - " Subset 0: () gives pval = 0.19791 / val = -0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V1 (4/21):\n", - " Subset 0: () gives pval = 0.07702 / val = 0.923\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V1 (5/21):\n", - " Subset 0: () gives pval = 0.96797 / val = -0.032\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V1 (6/21):\n", - " Subset 0: () gives pval = 0.09642 / val = -0.904\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V1 (7/21):\n", - " Subset 0: () gives pval = 0.44848 / val = -0.552\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V1 (8/21):\n", - " Subset 0: () gives pval = 0.68330 / val = 0.317\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V1 (9/21):\n", - " Subset 0: () gives pval = 0.54066 / val = 0.459\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V1 (10/21):\n", - " Subset 0: () gives pval = 0.29779 / val = -0.702\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V1 (11/21):\n", - " Subset 0: () gives pval = 0.52864 / val = -0.471\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V1 (12/21):\n", - " Subset 0: () gives pval = 0.20579 / val = 0.794\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V1 (13/21):\n", - " Subset 0: () gives pval = 0.39236 / val = 0.608\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V1 (14/21):\n", - " Subset 0: () gives pval = 0.67772 / val = -0.322\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V1 (15/21):\n", - " Subset 0: () gives pval = 0.21445 / val = 0.786\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V1 (16/21):\n", - " Subset 0: () gives pval = 0.07663 / val = -0.923\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V1 (17/21):\n", - " Subset 0: () gives pval = 0.90942 / val = -0.091\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V1 (18/21):\n", - " Subset 0: () gives pval = 0.24793 / val = 0.752\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V1 (19/21):\n", - " Subset 0: () gives pval = 0.95866 / val = 0.041\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V1 (20/21):\n", - " Subset 0: () gives pval = 0.02837 / val = -0.972\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V1 (21/21):\n", - " Subset 0: () gives pval = 0.95338 / val = 0.047\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V1\n", - "\n", - "## Variable V2\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V2 (1/21):\n", - " Subset 0: () gives pval = 0.10887 / val = -0.891\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V2 (2/21):\n", - " Subset 0: () gives pval = 0.95900 / val = -0.041\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V2 (3/21):\n", - " Subset 0: () gives pval = 0.35587 / val = 0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V2 (4/21):\n", - " Subset 0: () gives pval = 0.84212 / val = -0.158\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V2 (5/21):\n", - " Subset 0: () gives pval = 0.02381 / val = -0.976\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V2 -3) -?> V2 (6/21):\n", - " Subset 0: () gives pval = 0.49923 / val = 0.501\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V2 (7/21):\n", - " Subset 0: () gives pval = 0.83019 / val = -0.170\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V2 (8/21):\n", - " Subset 0: () gives pval = 0.14931 / val = 0.851\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V2 (9/21):\n", - " Subset 0: () gives pval = 0.93518 / val = -0.065\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V2 (10/21):\n", - " Subset 0: () gives pval = 0.57191 / val = -0.428\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V2 (11/21):\n", - " Subset 0: () gives pval = 0.05965 / val = 0.940\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V2 (12/21):\n", - " Subset 0: () gives pval = 0.67197 / val = 0.328\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V2 (13/21):\n", - " Subset 0: () gives pval = 0.31401 / val = -0.686\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V2 (14/21):\n", - " Subset 0: () gives pval = 0.38770 / val = 0.612\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V2 (15/21):\n", - " Subset 0: () gives pval = 0.57992 / val = 0.420\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V2 (16/21):\n", - " Subset 0: () gives pval = 0.95332 / val = -0.047\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V2 (17/21):\n", - " Subset 0: () gives pval = 0.00295 / val = 0.997\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V6 -3) -?> V2 (18/21):\n", - " Subset 0: () gives pval = 0.89811 / val = 0.102\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V2 (19/21):\n", - " Subset 0: () gives pval = 0.29986 / val = -0.700\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V2 (20/21):\n", - " Subset 0: () gives pval = 0.92687 / val = 0.073\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V2 (21/21):\n", - " Subset 0: () gives pval = 0.02116 / val = 0.979\n", - " No conditions of dimension 0 left.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V2 has 3 link(s):\n", - " (V6 -2): max_pval = 0.00295, |min_val| = 0.997\n", - " (V7 -3): max_pval = 0.02116, |min_val| = 0.979\n", - " (V2 -2): max_pval = 0.02381, |min_val| = 0.976\n", - "\n", - "Testing condition sets of dimension 1:\n", - "\n", - " Link (V6 -2) -?> V2 (1/3):\n", - " Subset 0: (V7 -3) gives pval = 0.20519 / val = 0.949\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V2 (2/3):\n", - " Subset 0: (V6 -2) gives pval = 0.64098 / val = -0.535\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V2 (3/3):\n", - " Subset 0: (V6 -2) gives pval = 0.00000 / val = 1.000\n", - " No conditions of dimension 1 left.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.02381, |min_val| = 0.976\n", - "\n", - "Algorithm converged for variable V2\n", - "\n", - "## Variable V3\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V3 (1/21):\n", - " Subset 0: () gives pval = 0.75382 / val = -0.246\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V3 (2/21):\n", - " Subset 0: () gives pval = 0.84711 / val = 0.153\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V3 (3/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V3 (4/21):\n", - " Subset 0: () gives pval = 0.48971 / val = 0.510\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V3 (5/21):\n", - " Subset 0: () gives pval = 0.86516 / val = 0.135\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V3 (6/21):\n", - " Subset 0: () gives pval = 0.37746 / val = -0.623\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V3 (7/21):\n", - " Subset 0: () gives pval = 0.11338 / val = -0.887\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V3 (8/21):\n", - " Subset 0: () gives pval = 0.67814 / val = 0.322\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V3 (9/21):\n", - " Subset 0: () gives pval = 0.83884 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V3 (10/21):\n", - " Subset 0: () gives pval = 0.76348 / val = -0.237\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V3 (11/21):\n", - " Subset 0: () gives pval = 0.59220 / val = -0.408\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V3 (12/21):\n", - " Subset 0: () gives pval = 0.64658 / val = 0.353\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V3 (13/21):\n", - " Subset 0: () gives pval = 0.14720 / val = 0.853\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V3 (14/21):\n", - " Subset 0: () gives pval = 0.23881 / val = -0.761\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V3 (15/21):\n", - " Subset 0: () gives pval = 0.59382 / val = 0.406\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V3 (16/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V3 (17/21):\n", - " Subset 0: () gives pval = 0.80931 / val = -0.191\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V3 (18/21):\n", - " Subset 0: () gives pval = 0.78890 / val = 0.211\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V3 (19/21):\n", - " Subset 0: () gives pval = 0.47777 / val = 0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V3 (20/21):\n", - " Subset 0: () gives pval = 0.36364 / val = -0.636\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V3 (21/21):\n", - " Subset 0: () gives pval = 0.96075 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V3\n", - "\n", - "## Variable V4\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V4 (1/21):\n", - " Subset 0: () gives pval = 0.45446 / val = 0.546\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V4 (2/21):\n", - " Subset 0: () gives pval = 0.63860 / val = 0.361\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V4 (3/21):\n", - " Subset 0: () gives pval = 0.44451 / val = -0.555\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V4 (4/21):\n", - " Subset 0: () gives pval = 0.86082 / val = 0.139\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V4 (5/21):\n", - " Subset 0: () gives pval = 0.16334 / val = 0.837\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V4 (6/21):\n", - " Subset 0: () gives pval = 0.50949 / val = -0.491\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V4 (7/21):\n", - " Subset 0: () gives pval = 0.62576 / val = -0.374\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V4 (8/21):\n", - " Subset 0: () gives pval = 0.51092 / val = -0.489\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V4 (9/21):\n", - " Subset 0: () gives pval = 0.71429 / val = -0.286\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V4 (10/21):\n", - " Subset 0: () gives pval = 0.58069 / val = 0.419\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V4 (11/21):\n", - " Subset 0: () gives pval = 0.18066 / val = -0.819\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V4 (12/21):\n", - " Subset 0: () gives pval = 0.71082 / val = -0.289\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V4 (13/21):\n", - " Subset 0: () gives pval = 0.05509 / val = 0.945\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V4 (14/21):\n", - " Subset 0: () gives pval = 0.06126 / val = -0.939\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V4 (15/21):\n", - " Subset 0: () gives pval = 0.69139 / val = -0.309\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V4 (16/21):\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V4 (17/21):\n", - " Subset 0: () gives pval = 0.15485 / val = -0.845\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V4 (18/21):\n", - " Subset 0: () gives pval = 0.77546 / val = -0.225\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V4 (19/21):\n", - " Subset 0: () gives pval = 0.07418 / val = 0.926\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V4 (20/21):\n", - " Subset 0: () gives pval = 0.83884 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V4 (21/21):\n", - " Subset 0: () gives pval = 0.23452 / val = -0.765\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V4\n", - "\n", - "## Variable V5\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V5 (1/21):\n", - " Subset 0: () gives pval = 0.40591 / val = -0.594\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V5 (2/21):\n", - " Subset 0: () gives pval = 0.22108 / val = 0.779\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V5 (3/21):\n", - " Subset 0: () gives pval = 0.18784 / val = 0.812\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V5 (4/21):\n", - " Subset 0: () gives pval = 0.33692 / val = -0.663\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V5 (5/21):\n", - " Subset 0: () gives pval = 0.56614 / val = -0.434\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V5 (6/21):\n", - " Subset 0: () gives pval = 0.27666 / val = 0.723\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V5 (7/21):\n", - " Subset 0: () gives pval = 0.49057 / val = -0.509\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V5 (8/21):\n", - " Subset 0: () gives pval = 0.44520 / val = 0.555\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V5 (9/21):\n", - " Subset 0: () gives pval = 0.15734 / val = -0.843\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V5 (10/21):\n", - " Subset 0: () gives pval = 0.66704 / val = 0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V5 (11/21):\n", - " Subset 0: () gives pval = 0.27833 / val = 0.722\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V5 (12/21):\n", - " Subset 0: () gives pval = 0.62823 / val = -0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V5 (13/21):\n", - " Subset 0: () gives pval = 0.82850 / val = -0.171\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V5 (14/21):\n", - " Subset 0: () gives pval = 0.86689 / val = -0.133\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V5 (15/21):\n", - " Subset 0: () gives pval = 0.76662 / val = -0.233\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V5 (16/21):\n", - " Subset 0: () gives pval = 0.48656 / val = 0.513\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V5 (17/21):\n", - " Subset 0: () gives pval = 0.46312 / val = 0.537\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V5 (18/21):\n", - " Subset 0: () gives pval = 0.35473 / val = -0.645\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V5 (19/21):\n", - " Subset 0: () gives pval = 0.85997 / val = 0.140\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V5 (20/21):\n", - " Subset 0: () gives pval = 0.48811 / val = 0.512\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V5 (21/21):\n", - " Subset 0: () gives pval = 0.46322 / val = 0.537\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V5\n", - "\n", - "## Variable V6\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V6 (1/21):\n", - " Subset 0: () gives pval = 0.72783 / val = 0.272\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V6 (2/21):\n", - " Subset 0: () gives pval = 0.15485 / val = 0.845\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V6 (3/21):\n", - " Subset 0: () gives pval = 0.96151 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V6 (4/21):\n", - " Subset 0: () gives pval = 0.60943 / val = -0.391\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V6 (5/21):\n", - " Subset 0: () gives pval = 0.40372 / val = 0.596\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V6 (6/21):\n", - " Subset 0: () gives pval = 0.92353 / val = 0.076\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V6 (7/21):\n", - " Subset 0: () gives pval = 0.48656 / val = -0.513\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V6 (8/21):\n", - " Subset 0: () gives pval = 0.74584 / val = -0.254\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V6 (9/21):\n", - " Subset 0: () gives pval = 0.19822 / val = -0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V6 (10/21):\n", - " Subset 0: () gives pval = 0.28091 / val = 0.719\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V6 (11/21):\n", - " Subset 0: () gives pval = 0.66939 / val = -0.331\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V6 (12/21):\n", - " Subset 0: () gives pval = 0.36883 / val = -0.631\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V6 (13/21):\n", - " Subset 0: () gives pval = 0.29289 / val = 0.707\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V6 (14/21):\n", - " Subset 0: () gives pval = 0.08530 / val = -0.915\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V6 (15/21):\n", - " Subset 0: () gives pval = 0.42265 / val = -0.577\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V6 (16/21):\n", - " Subset 0: () gives pval = 0.55095 / val = 0.449\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V6 (17/21):\n", - " Subset 0: () gives pval = 0.47295 / val = -0.527\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V6 (18/21):\n", - " Subset 0: () gives pval = 0.29986 / val = -0.700\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V6 (19/21):\n", - " Subset 0: () gives pval = 0.03775 / val = 0.962\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V6 (20/21):\n", - " Subset 0: () gives pval = 0.69849 / val = 0.302\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V6 (21/21):\n", - " Subset 0: () gives pval = 0.52264 / val = -0.477\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V6\n", - "\n", - "## Variable V7\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V7 (1/21):\n", - " Subset 0: () gives pval = 0.52860 / val = 0.471\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V7 (2/21):\n", - " Subset 0: () gives pval = 0.12169 / val = -0.878\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V7 (3/21):\n", - " Subset 0: () gives pval = 0.26667 / val = -0.733\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V7 (4/21):\n", - " Subset 0: () gives pval = 0.32352 / val = 0.676\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V7 (5/21):\n", - " Subset 0: () gives pval = 0.74180 / val = 0.258\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V7 (6/21):\n", - " Subset 0: () gives pval = 0.33773 / val = -0.662\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V7 (7/21):\n", - " Subset 0: () gives pval = 0.43408 / val = 0.566\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V7 (8/21):\n", - " Subset 0: () gives pval = 0.55977 / val = -0.440\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V7 (9/21):\n", - " Subset 0: () gives pval = 0.07418 / val = 0.926\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V7 (10/21):\n", - " Subset 0: () gives pval = 0.54709 / val = -0.453\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V7 (11/21):\n", - " Subset 0: () gives pval = 0.42736 / val = -0.573\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V7 (12/21):\n", - " Subset 0: () gives pval = 0.53148 / val = 0.469\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V7 (13/21):\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V7 (14/21):\n", - " Subset 0: () gives pval = 0.68314 / val = 0.317\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V7 (15/21):\n", - " Subset 0: () gives pval = 0.66667 / val = 0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V7 (16/21):\n", - " Subset 0: () gives pval = 0.44444 / val = -0.556\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V7 (17/21):\n", - " Subset 0: () gives pval = 0.63485 / val = -0.365\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V7 (18/21):\n", - " Subset 0: () gives pval = 0.27239 / val = 0.728\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V7 (19/21):\n", - " Subset 0: () gives pval = 0.66667 / val = -0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V7 (20/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V7 (21/21):\n", - " Subset 0: () gives pval = 0.62418 / val = -0.376\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V7\n", - "\n", - "## Resulting lagged parent (super)sets:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.02381, |min_val| = 0.976\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "##\n", - "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", - "##\n", - "\n", - "Parameters:\n", - "\n", - "independence test = par_corr\n", - "tau_min = 0\n", - "tau_max = 3\n", - "pc_alpha = 0.025\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "reset_lagged_links = False\n", - "max_conds_dim = None\n", - "max_conds_py = None\n", - "max_conds_px = None\n", - "max_conds_px_lagged = None\n", - "fdr_method = none\n", - "\n", - "--------------------------\n", - "Skeleton discovery phase\n", - "--------------------------\n", - "\n", - "Testing contemporaneous condition sets of dimension 0: \n", - "\n", - " Link (V1 0) o?o V2 (1/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V2 -2) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.33446 / val = -0.865\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V3 (2/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.20111 / val = 0.799\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V4 (3/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.65550 / val = 0.345\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V5 (4/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.60053 / val = -0.399\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V6 (5/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.92839 / val = -0.072\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V7 (6/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.62790 / val = 0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V1 (7/43):\n", - " Already removed.\n", - "\n", - " Link (V2 -2) -?> V2 (8/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -4) ]\n", - " Subset 0: () gives pval = 0.16206 / val = -0.968\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V3 (9/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.73228 / val = -0.408\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V4 (10/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.85995 / val = -0.218\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V5 (11/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.36193 / val = 0.843\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V6 (12/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.62384 / val = 0.557\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V7 (13/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.40777 / val = -0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V1 (14/43):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V2 (15/43):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V4 (16/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.35534 / val = 0.645\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V5 (17/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.92687 / val = 0.073\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V6 (18/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.49748 / val = 0.503\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V7 (19/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.82592 / val = -0.174\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V1 (20/43):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V2 (21/43):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V3 (22/43):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V5 (23/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.80554 / val = -0.194\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V6 (24/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.19822 / val = 0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V7 (25/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V1 (26/43):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V2 (27/43):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V3 (28/43):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V4 (29/43):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V6 (30/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.59577 / val = 0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V7 (31/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.01980 / val = -0.980\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V6 0) o?o V1 (32/43):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V2 (33/43):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V3 (34/43):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V4 (35/43):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V5 (36/43):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V7 (37/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.42265 / val = -0.577\n", - " Non-significance detected.\n", - "\n", - " Link (V7 0) o?o V1 (38/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V2 (39/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V3 (40/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V4 (41/43):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V5 (42/43):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.01980 / val = -0.980\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V7 0) o?o V6 (43/43):\n", - " Already removed.\n", - "\n", - "Updated contemp. adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 1 link(s):\n", - " (V7 0): max_pval = 0.01980, |min_val| = 0.980\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 1 link(s):\n", - " (V5 0): max_pval = 0.01980, |min_val| = 0.980\n", - "\n", - "Algorithm converged at p = 0.\n", - "\n", - "----------------------------\n", - "Collider orientation phase\n", - "----------------------------\n", - "\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 1 link(s):\n", - " (V7 0)\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 1 link(s):\n", - " (V5 0)\n", - "\n", - "\n", - "----------------------------\n", - "Rule orientation phase\n", - "----------------------------\n", - "\n", - "Try rule(s) [1 2 3]\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 1 link(s):\n", - " (V7 0)\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 1 link(s):\n", - " (V5 0)\n", - "\n", - "## Significant links at alpha = 0.025:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 1 link(s):\n", - " (V7 0): pval = 0.01980 | val = -0.980 | unoriented link\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 1 link(s):\n", - " (V5 0): pval = 0.01980 | val = -0.980 | unoriented link\n", - "\n", - "## pc_alpha = 0.05 (5/5):\n", - "\n", - "##\n", - "## Step 1: PC1 algorithm for selecting lagged conditions\n", - "##\n", - "\n", - "Parameters:\n", - "independence test = par_corr\n", - "tau_min = 1\n", - "tau_max = 3\n", - "pc_alpha = [0.05]\n", - "max_conds_dim = None\n", - "max_combinations = 1\n", - "\n", - "\n", - "\n", - "## Variable V1\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V1 (1/21):\n", - " Subset 0: () gives pval = 0.76612 / val = -0.234\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V1 (2/21):\n", - " Subset 0: () gives pval = 0.52792 / val = -0.472\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V1 (3/21):\n", - " Subset 0: () gives pval = 0.19791 / val = -0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V1 (4/21):\n", - " Subset 0: () gives pval = 0.07702 / val = 0.923\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V1 (5/21):\n", - " Subset 0: () gives pval = 0.96797 / val = -0.032\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V1 (6/21):\n", - " Subset 0: () gives pval = 0.09642 / val = -0.904\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V1 (7/21):\n", - " Subset 0: () gives pval = 0.44848 / val = -0.552\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V1 (8/21):\n", - " Subset 0: () gives pval = 0.68330 / val = 0.317\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V1 (9/21):\n", - " Subset 0: () gives pval = 0.54066 / val = 0.459\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V1 (10/21):\n", - " Subset 0: () gives pval = 0.29779 / val = -0.702\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V1 (11/21):\n", - " Subset 0: () gives pval = 0.52864 / val = -0.471\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V1 (12/21):\n", - " Subset 0: () gives pval = 0.20579 / val = 0.794\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V1 (13/21):\n", - " Subset 0: () gives pval = 0.39236 / val = 0.608\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V1 (14/21):\n", - " Subset 0: () gives pval = 0.67772 / val = -0.322\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V1 (15/21):\n", - " Subset 0: () gives pval = 0.21445 / val = 0.786\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V1 (16/21):\n", - " Subset 0: () gives pval = 0.07663 / val = -0.923\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V1 (17/21):\n", - " Subset 0: () gives pval = 0.90942 / val = -0.091\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V1 (18/21):\n", - " Subset 0: () gives pval = 0.24793 / val = 0.752\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V1 (19/21):\n", - " Subset 0: () gives pval = 0.95866 / val = 0.041\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V1 (20/21):\n", - " Subset 0: () gives pval = 0.02837 / val = -0.972\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V7 -3) -?> V1 (21/21):\n", - " Subset 0: () gives pval = 0.95338 / val = 0.047\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V1 has 1 link(s):\n", - " (V7 -2): max_pval = 0.02837, |min_val| = 0.972\n", - "\n", - "Algorithm converged for variable V1\n", - "\n", - "## Variable V2\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V2 (1/21):\n", - " Subset 0: () gives pval = 0.10887 / val = -0.891\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V2 (2/21):\n", - " Subset 0: () gives pval = 0.95900 / val = -0.041\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V2 (3/21):\n", - " Subset 0: () gives pval = 0.35587 / val = 0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V2 (4/21):\n", - " Subset 0: () gives pval = 0.84212 / val = -0.158\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V2 (5/21):\n", - " Subset 0: () gives pval = 0.02381 / val = -0.976\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V2 -3) -?> V2 (6/21):\n", - " Subset 0: () gives pval = 0.49923 / val = 0.501\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V2 (7/21):\n", - " Subset 0: () gives pval = 0.83019 / val = -0.170\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V2 (8/21):\n", - " Subset 0: () gives pval = 0.14931 / val = 0.851\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V2 (9/21):\n", - " Subset 0: () gives pval = 0.93518 / val = -0.065\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V2 (10/21):\n", - " Subset 0: () gives pval = 0.57191 / val = -0.428\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V2 (11/21):\n", - " Subset 0: () gives pval = 0.05965 / val = 0.940\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V2 (12/21):\n", - " Subset 0: () gives pval = 0.67197 / val = 0.328\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V2 (13/21):\n", - " Subset 0: () gives pval = 0.31401 / val = -0.686\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V2 (14/21):\n", - " Subset 0: () gives pval = 0.38770 / val = 0.612\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V2 (15/21):\n", - " Subset 0: () gives pval = 0.57992 / val = 0.420\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V2 (16/21):\n", - " Subset 0: () gives pval = 0.95332 / val = -0.047\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V2 (17/21):\n", - " Subset 0: () gives pval = 0.00295 / val = 0.997\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V6 -3) -?> V2 (18/21):\n", - " Subset 0: () gives pval = 0.89811 / val = 0.102\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V2 (19/21):\n", - " Subset 0: () gives pval = 0.29986 / val = -0.700\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V2 (20/21):\n", - " Subset 0: () gives pval = 0.92687 / val = 0.073\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V2 (21/21):\n", - " Subset 0: () gives pval = 0.02116 / val = 0.979\n", - " No conditions of dimension 0 left.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V2 has 3 link(s):\n", - " (V6 -2): max_pval = 0.00295, |min_val| = 0.997\n", - " (V7 -3): max_pval = 0.02116, |min_val| = 0.979\n", - " (V2 -2): max_pval = 0.02381, |min_val| = 0.976\n", - "\n", - "Testing condition sets of dimension 1:\n", - "\n", - " Link (V6 -2) -?> V2 (1/3):\n", - " Subset 0: (V7 -3) gives pval = 0.20519 / val = 0.949\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V2 (2/3):\n", - " Subset 0: (V6 -2) gives pval = 0.64098 / val = -0.535\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V2 (3/3):\n", - " Subset 0: (V6 -2) gives pval = 0.00000 / val = 1.000\n", - " No conditions of dimension 1 left.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.02381, |min_val| = 0.976\n", - "\n", - "Algorithm converged for variable V2\n", - "\n", - "## Variable V3\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V3 (1/21):\n", - " Subset 0: () gives pval = 0.75382 / val = -0.246\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V3 (2/21):\n", - " Subset 0: () gives pval = 0.84711 / val = 0.153\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V3 (3/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V3 (4/21):\n", - " Subset 0: () gives pval = 0.48971 / val = 0.510\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V3 (5/21):\n", - " Subset 0: () gives pval = 0.86516 / val = 0.135\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V3 (6/21):\n", - " Subset 0: () gives pval = 0.37746 / val = -0.623\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V3 (7/21):\n", - " Subset 0: () gives pval = 0.11338 / val = -0.887\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V3 (8/21):\n", - " Subset 0: () gives pval = 0.67814 / val = 0.322\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V3 (9/21):\n", - " Subset 0: () gives pval = 0.83884 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V3 (10/21):\n", - " Subset 0: () gives pval = 0.76348 / val = -0.237\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V3 (11/21):\n", - " Subset 0: () gives pval = 0.59220 / val = -0.408\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V3 (12/21):\n", - " Subset 0: () gives pval = 0.64658 / val = 0.353\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V3 (13/21):\n", - " Subset 0: () gives pval = 0.14720 / val = 0.853\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V3 (14/21):\n", - " Subset 0: () gives pval = 0.23881 / val = -0.761\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V3 (15/21):\n", - " Subset 0: () gives pval = 0.59382 / val = 0.406\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V3 (16/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V3 (17/21):\n", - " Subset 0: () gives pval = 0.80931 / val = -0.191\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V3 (18/21):\n", - " Subset 0: () gives pval = 0.78890 / val = 0.211\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V3 (19/21):\n", - " Subset 0: () gives pval = 0.47777 / val = 0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V3 (20/21):\n", - " Subset 0: () gives pval = 0.36364 / val = -0.636\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V3 (21/21):\n", - " Subset 0: () gives pval = 0.96075 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V3\n", - "\n", - "## Variable V4\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V4 (1/21):\n", - " Subset 0: () gives pval = 0.45446 / val = 0.546\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V4 (2/21):\n", - " Subset 0: () gives pval = 0.63860 / val = 0.361\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V4 (3/21):\n", - " Subset 0: () gives pval = 0.44451 / val = -0.555\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V4 (4/21):\n", - " Subset 0: () gives pval = 0.86082 / val = 0.139\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V4 (5/21):\n", - " Subset 0: () gives pval = 0.16334 / val = 0.837\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V4 (6/21):\n", - " Subset 0: () gives pval = 0.50949 / val = -0.491\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V4 (7/21):\n", - " Subset 0: () gives pval = 0.62576 / val = -0.374\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V4 (8/21):\n", - " Subset 0: () gives pval = 0.51092 / val = -0.489\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V4 (9/21):\n", - " Subset 0: () gives pval = 0.71429 / val = -0.286\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V4 (10/21):\n", - " Subset 0: () gives pval = 0.58069 / val = 0.419\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V4 (11/21):\n", - " Subset 0: () gives pval = 0.18066 / val = -0.819\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V4 (12/21):\n", - " Subset 0: () gives pval = 0.71082 / val = -0.289\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V4 (13/21):\n", - " Subset 0: () gives pval = 0.05509 / val = 0.945\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V4 (14/21):\n", - " Subset 0: () gives pval = 0.06126 / val = -0.939\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V4 (15/21):\n", - " Subset 0: () gives pval = 0.69139 / val = -0.309\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V4 (16/21):\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V4 (17/21):\n", - " Subset 0: () gives pval = 0.15485 / val = -0.845\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V4 (18/21):\n", - " Subset 0: () gives pval = 0.77546 / val = -0.225\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V4 (19/21):\n", - " Subset 0: () gives pval = 0.07418 / val = 0.926\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V4 (20/21):\n", - " Subset 0: () gives pval = 0.83884 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V4 (21/21):\n", - " Subset 0: () gives pval = 0.23452 / val = -0.765\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V4\n", - "\n", - "## Variable V5\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V5 (1/21):\n", - " Subset 0: () gives pval = 0.40591 / val = -0.594\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V5 (2/21):\n", - " Subset 0: () gives pval = 0.22108 / val = 0.779\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V5 (3/21):\n", - " Subset 0: () gives pval = 0.18784 / val = 0.812\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V5 (4/21):\n", - " Subset 0: () gives pval = 0.33692 / val = -0.663\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V5 (5/21):\n", - " Subset 0: () gives pval = 0.56614 / val = -0.434\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V5 (6/21):\n", - " Subset 0: () gives pval = 0.27666 / val = 0.723\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V5 (7/21):\n", - " Subset 0: () gives pval = 0.49057 / val = -0.509\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V5 (8/21):\n", - " Subset 0: () gives pval = 0.44520 / val = 0.555\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V5 (9/21):\n", - " Subset 0: () gives pval = 0.15734 / val = -0.843\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V5 (10/21):\n", - " Subset 0: () gives pval = 0.66704 / val = 0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V5 (11/21):\n", - " Subset 0: () gives pval = 0.27833 / val = 0.722\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V5 (12/21):\n", - " Subset 0: () gives pval = 0.62823 / val = -0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V5 (13/21):\n", - " Subset 0: () gives pval = 0.82850 / val = -0.171\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V5 (14/21):\n", - " Subset 0: () gives pval = 0.86689 / val = -0.133\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V5 (15/21):\n", - " Subset 0: () gives pval = 0.76662 / val = -0.233\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V5 (16/21):\n", - " Subset 0: () gives pval = 0.48656 / val = 0.513\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V5 (17/21):\n", - " Subset 0: () gives pval = 0.46312 / val = 0.537\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V5 (18/21):\n", - " Subset 0: () gives pval = 0.35473 / val = -0.645\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V5 (19/21):\n", - " Subset 0: () gives pval = 0.85997 / val = 0.140\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V5 (20/21):\n", - " Subset 0: () gives pval = 0.48811 / val = 0.512\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V5 (21/21):\n", - " Subset 0: () gives pval = 0.46322 / val = 0.537\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V5\n", - "\n", - "## Variable V6\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V6 (1/21):\n", - " Subset 0: () gives pval = 0.72783 / val = 0.272\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V6 (2/21):\n", - " Subset 0: () gives pval = 0.15485 / val = 0.845\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V6 (3/21):\n", - " Subset 0: () gives pval = 0.96151 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V6 (4/21):\n", - " Subset 0: () gives pval = 0.60943 / val = -0.391\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V6 (5/21):\n", - " Subset 0: () gives pval = 0.40372 / val = 0.596\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V6 (6/21):\n", - " Subset 0: () gives pval = 0.92353 / val = 0.076\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V6 (7/21):\n", - " Subset 0: () gives pval = 0.48656 / val = -0.513\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V6 (8/21):\n", - " Subset 0: () gives pval = 0.74584 / val = -0.254\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V6 (9/21):\n", - " Subset 0: () gives pval = 0.19822 / val = -0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V6 (10/21):\n", - " Subset 0: () gives pval = 0.28091 / val = 0.719\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V6 (11/21):\n", - " Subset 0: () gives pval = 0.66939 / val = -0.331\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V6 (12/21):\n", - " Subset 0: () gives pval = 0.36883 / val = -0.631\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V6 (13/21):\n", - " Subset 0: () gives pval = 0.29289 / val = 0.707\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V6 (14/21):\n", - " Subset 0: () gives pval = 0.08530 / val = -0.915\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V6 (15/21):\n", - " Subset 0: () gives pval = 0.42265 / val = -0.577\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V6 (16/21):\n", - " Subset 0: () gives pval = 0.55095 / val = 0.449\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V6 (17/21):\n", - " Subset 0: () gives pval = 0.47295 / val = -0.527\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V6 (18/21):\n", - " Subset 0: () gives pval = 0.29986 / val = -0.700\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V6 (19/21):\n", - " Subset 0: () gives pval = 0.03775 / val = 0.962\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V7 -2) -?> V6 (20/21):\n", - " Subset 0: () gives pval = 0.69849 / val = 0.302\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V6 (21/21):\n", - " Subset 0: () gives pval = 0.52264 / val = -0.477\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): max_pval = 0.03775, |min_val| = 0.962\n", - "\n", - "Algorithm converged for variable V6\n", - "\n", - "## Variable V7\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V7 (1/21):\n", - " Subset 0: () gives pval = 0.52860 / val = 0.471\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V7 (2/21):\n", - " Subset 0: () gives pval = 0.12169 / val = -0.878\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V7 (3/21):\n", - " Subset 0: () gives pval = 0.26667 / val = -0.733\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V7 (4/21):\n", - " Subset 0: () gives pval = 0.32352 / val = 0.676\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V7 (5/21):\n", - " Subset 0: () gives pval = 0.74180 / val = 0.258\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V7 (6/21):\n", - " Subset 0: () gives pval = 0.33773 / val = -0.662\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V7 (7/21):\n", - " Subset 0: () gives pval = 0.43408 / val = 0.566\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V7 (8/21):\n", - " Subset 0: () gives pval = 0.55977 / val = -0.440\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V7 (9/21):\n", - " Subset 0: () gives pval = 0.07418 / val = 0.926\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V7 (10/21):\n", - " Subset 0: () gives pval = 0.54709 / val = -0.453\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V7 (11/21):\n", - " Subset 0: () gives pval = 0.42736 / val = -0.573\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V7 (12/21):\n", - " Subset 0: () gives pval = 0.53148 / val = 0.469\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V7 (13/21):\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V7 (14/21):\n", - " Subset 0: () gives pval = 0.68314 / val = 0.317\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V7 (15/21):\n", - " Subset 0: () gives pval = 0.66667 / val = 0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V7 (16/21):\n", - " Subset 0: () gives pval = 0.44444 / val = -0.556\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V7 (17/21):\n", - " Subset 0: () gives pval = 0.63485 / val = -0.365\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V7 (18/21):\n", - " Subset 0: () gives pval = 0.27239 / val = 0.728\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V7 (19/21):\n", - " Subset 0: () gives pval = 0.66667 / val = -0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V7 (20/21):\n", - " Subset 0: () gives pval = 0.47777 / val = -0.522\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V7 (21/21):\n", - " Subset 0: () gives pval = 0.62418 / val = -0.376\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V7\n", - "\n", - "## Resulting lagged parent (super)sets:\n", - "\n", - " Variable V1 has 1 link(s):\n", - " (V7 -2): max_pval = 0.02837, |min_val| = 0.972\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.02381, |min_val| = 0.976\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): max_pval = 0.03775, |min_val| = 0.962\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "##\n", - "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", - "##\n", - "\n", - "Parameters:\n", - "\n", - "independence test = par_corr\n", - "tau_min = 0\n", - "tau_max = 3\n", - "pc_alpha = 0.05\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "reset_lagged_links = False\n", - "max_conds_dim = None\n", - "max_conds_py = None\n", - "max_conds_px = None\n", - "max_conds_px_lagged = None\n", - "fdr_method = none\n", - "\n", - "--------------------------\n", - "Skeleton discovery phase\n", - "--------------------------\n", - "\n", - "Testing contemporaneous condition sets of dimension 0: \n", - "\n", - " Link (V1 0) o?o V2 (1/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V2 -2) ]\n", - " with conds_x = [ (V7 -2) ]\n", - " Subset 0: () gives pval = nan / val = 1.000\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V3 (2/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V7 -2) ]\n", - " Subset 0: () gives pval = 0.09117 / val = 0.990\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V4 (3/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V7 -2) ]\n", - " Subset 0: () gives pval = 0.40435 / val = 0.805\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V5 (4/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V7 -2) ]\n", - " Subset 0: () gives pval = 0.67997 / val = 0.482\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V6 (5/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ (V7 -2) ]\n", - " Subset 0: () gives pval = nan / val = 1.000\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V7 (6/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V7 -2) ]\n", - " Subset 0: () gives pval = 0.53188 / val = -0.671\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V1 (7/45):\n", - " Already removed.\n", - "\n", - " Link (V2 -2) -?> V2 (8/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -4) ]\n", - " Subset 0: () gives pval = 0.16206 / val = -0.968\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V3 (9/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.73228 / val = -0.408\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V4 (10/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.85995 / val = -0.218\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V5 (11/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.36193 / val = 0.843\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V6 (12/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = nan / val = 1.000\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V7 (13/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.40777 / val = -0.802\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V1 (14/45):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V2 (15/45):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V4 (16/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.35534 / val = 0.645\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V5 (17/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.92687 / val = 0.073\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V6 (18/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V7 (19/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.82592 / val = -0.174\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V1 (20/45):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V2 (21/45):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V3 (22/45):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V5 (23/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.80554 / val = -0.194\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V6 (24/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.33333 / val = -0.866\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V7 (25/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 1.00000 / val = 0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V1 (26/45):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V2 (27/45):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V3 (28/45):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V4 (29/45):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V6 (30/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.00000 / val = 1.000\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V5 0) o?o V7 (31/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.01980 / val = -0.980\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V6 0) o?o V1 (32/45):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V2 (33/45):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V3 (34/45):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V4 (35/45):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V5 (36/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V7 -1) ]\n", - " Subset 0: () gives pval = 0.00000 / val = 1.000\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V6 0) o?o V7 (37/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V7 -1) ]\n", - " Subset 0: () gives pval = 0.00000 / val = -1.000\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V7 0) o?o V1 (38/45):\n", - " Already removed.\n", - "\n", - " Link (V7 -2) -?> V1 (39/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.02837 / val = -0.972\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V7 0) o?o V2 (40/45):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V3 (41/45):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V4 (42/45):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V5 (43/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.01980 / val = -0.980\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V7 0) o?o V6 (44/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.00000 / val = -1.000\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V7 -1) -?> V6 (45/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.03775 / val = 0.962\n", - " No conditions of dimension 0 left.\n", - "\n", - "Updated contemp. adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 2 link(s):\n", - " (V6 0): max_pval = 0.00000, |min_val| = 1.000\n", - " (V7 0): max_pval = 0.01980, |min_val| = 0.980\n", - "\n", - " Variable V6 has 2 link(s):\n", - " (V5 0): max_pval = 0.00000, |min_val| = 1.000\n", - " (V7 0): max_pval = 0.00000, |min_val| = 1.000\n", - "\n", - " Variable V7 has 2 link(s):\n", - " (V6 0): max_pval = 0.00000, |min_val| = 1.000\n", - " (V5 0): max_pval = 0.01980, |min_val| = 0.980\n", - "\n", - "Testing contemporaneous condition sets of dimension 1: \n", - "\n", - " Link (V5 0) o?o V6 (1/7):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: (V7 0) gives pval = nan / val = -0.939\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V7 (2/7):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: (V6 0) gives pval = 0.00000 / val = -1.000\n", - " No conditions of dimension 1 left.\n", - "\n", - " Link (V6 0) o?o V5 (3/7):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V7 (4/7):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V7 -1) ]\n", - " Subset 0: (V5 0) gives pval = nan / val = -0.778\n", - " Non-significance detected.\n", - "\n", - " Link (V7 0) o?o V5 (5/7):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: (V6 0) gives pval = 0.00000 / val = -1.000\n", - " No conditions of dimension 1 left.\n", - "\n", - " Link (V7 0) o?o V6 (6/7):\n", - " Already removed.\n", - "\n", - " Link (V7 -1) -?> V6 (7/7):\n", - " Iterate through 2 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: (V5 0) gives pval = 0.00000 / val = 1.000\n", - " Subset 1: (V7 0) gives pval = 0.00000 / val = 1.000\n", - " No conditions of dimension 1 left.\n", - "\n", - "Updated contemp. adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 1 link(s):\n", - " (V7 0): max_pval = 0.01980, |min_val| = 0.980\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 1 link(s):\n", - " (V5 0): max_pval = 0.01980, |min_val| = 0.980\n", - "\n", - "Algorithm converged at p = 1.\n", - "\n", - "----------------------------\n", - "Collider orientation phase\n", - "----------------------------\n", - "\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 1 link(s):\n", - " (V7 -2)\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 1 link(s):\n", - " (V7 0)\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1)\n", - "\n", - " Variable V7 has 1 link(s):\n", - " (V5 0)\n", - "\n", - "\n", - "----------------------------\n", - "Rule orientation phase\n", - "----------------------------\n", - "\n", - "Try rule(s) [1 2 3]\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 1 link(s):\n", - " (V7 -2)\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 1 link(s):\n", - " (V7 0)\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1)\n", - "\n", - " Variable V7 has 1 link(s):\n", - " (V5 0)\n", - "\n", - "## Significant links at alpha = 0.05:\n", - "\n", - " Variable V1 has 1 link(s):\n", - " (V7 -2): pval = 0.02837 | val = -0.972\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 1 link(s):\n", - " (V7 0): pval = 0.01980 | val = -0.980 | unoriented link\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): pval = 0.03775 | val = 0.962\n", - "\n", - " Variable V7 has 1 link(s):\n", - " (V5 0): pval = 0.01980 | val = -0.980 | unoriented link\n", - "\n", - "##\n", - "\n", - "## Scores for individual pc_alpha values:\n", - "\n", - " pc_alpha = 0.001 yields score = 7.54518\n", - " pc_alpha = 0.005 yields score = 4.89615\n", - " pc_alpha = 0.01 yields score = 4.89615\n", - " pc_alpha = 0.025 yields score = 5.98022\n", - " pc_alpha = 0.05 yields score = 3.41674\n", - "\n", - "##\n", - "## Results for optimal pc_alpha = 0.05\n", - "##\n", - "\n", - "## Significant links at alpha = 0.05:\n", - "\n", - " Variable V1 has 1 link(s):\n", - " (V7 -2): pval = 0.02837 | val = -0.972\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 1 link(s):\n", - " (V7 0): pval = 0.01980 | val = -0.980 | unoriented link\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): pval = 0.03775 | val = 0.962\n", - "\n", - " Variable V7 has 1 link(s):\n", - " (V5 0): pval = 0.01980 | val = -0.980 | unoriented link\n" - ] - } - ], + "outputs": [], "source": [ "tau_max = 3\n", "pc_alpha = None\n", @@ -6035,20 +267,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from dowhy.utils.timeseries import create_graph_from_networkx_array\n", "\n", From bf731bbf6754dee8ddf439b9c8d46a1b79674301 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Tue, 30 Jul 2024 04:10:08 +0000 Subject: [PATCH 45/67] find ancestors --- dowhy/timeseries/temporal_shift.py | 27 ++++++++++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-) diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 903fef2a1..22055f18a 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -3,6 +3,22 @@ import networkx as nx import pandas as pd +def find_ancestors(graph: nx.DiGraph, node: str) -> List[str]: + """ + Given a graph and a node, this function returns the ancestor nodes of the node that are not parents. + + :param graph: The graph object. + :type graph: networkx.Graph + :param node: The node for which we want to find the ancestor nodes. + :type node: string + :return: A list of ancestor nodes of the node. + :rtype: list + """ + ancestors = [] + for n in nx.ancestors(graph, node): + if n not in graph.predecessors(node): + ancestors.append(n) + return ancestors def find_lagged_parents(graph: nx.DiGraph, node: str) -> Tuple[List[str], List[int]]: """ @@ -26,7 +42,7 @@ def find_lagged_parents(graph: nx.DiGraph, node: str) -> Tuple[List[str], List[i def shift_columns_by_lag( - df: pd.DataFrame, columns: List[str], lag: List[int], filter: bool, child_node: Optional[str] = None + df: pd.DataFrame, columns: List[str], lag: List[int], ancestors: List[str], filter: bool, child_node: Optional[str] = None ) -> pd.DataFrame: """ Given a dataframe, a list of columns, and a list of time lags, this function shifts the columns in the dataframe by the corresponding time lags, creating a new unique column for each shifted version. @@ -36,8 +52,10 @@ def shift_columns_by_lag( :type df: pandas.DataFrame :param columns: A list of columns to shift. :type columns: list - :param lags: A list of time lags to shift the columns by. - :type lags: list + :param lag: A list of time lags to shift the columns by. + :type lag: list + :param ancestors: A list of ancestor nodes of the child node. + :type ancestors: list :param filter: A boolean indicating whether to filter the dataframe to keep only relevant columns. :type filter: bool :param child_node: The child node to keep when filtering. @@ -64,5 +82,8 @@ def shift_columns_by_lag( ) relevant_columns = list(dict.fromkeys(relevant_columns)) # Ensure unique and maintain order new_df = new_df[relevant_columns] + + for ancestor in ancestors: + new_df[ancestor] = df[ancestor] return new_df From e488713a3f2ee7aedf9e706aa725e9ba07a221ca Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Tue, 30 Jul 2024 04:11:40 +0000 Subject: [PATCH 46/67] include ancestors in notebook --- .../effect_inference_timeseries_data.ipynb | 21 ++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index 31500194c..20a3821bc 100644 --- a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -108,7 +108,7 @@ "metadata": {}, "outputs": [], "source": [ - "from dowhy.timeseries.temporal_shift import find_lagged_parents,shift_columns_by_lag" + "from dowhy.timeseries.temporal_shift import find_lagged_parents,shift_columns_by_lag, find_ancestors" ] }, { @@ -122,7 +122,9 @@ "\n", "# find the action nodes of the given target node with respective lag times\n", "parents, time_lags = find_lagged_parents(graph, target_node)\n", - "print (\"Parents of the target node with respective time lags: \", parents, time_lags)" + "ancestors = find_ancestors(graph, target_node)\n", + "print (\"Parents of the target node with respective time lags: \", parents, time_lags)\n", + "print (\"Ancestors of the target node: \", ancestors)" ] }, { @@ -140,7 +142,7 @@ "metadata": {}, "outputs": [], "source": [ - "time_shifted_df = shift_columns_by_lag(dataframe,parents,time_lags,filter=True, child_node=target_node)\n", + "time_shifted_df = shift_columns_by_lag(dataframe,parents,time_lags,ancestors,filter=True, child_node=target_node)\n", "time_shifted_df.head()" ] }, @@ -160,11 +162,20 @@ "outputs": [], "source": [ "treatment = 'V7'\n", - "# Rename the lagged treatment columns to avoid ambiguity\n", "treatment_columns = [treatment] + [f\"{treatment}_lag{i}\" for i in range(1, int(time_lags[parents.index(treatment)] + 1) ) ]\n", "treatment_columns" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "treatment_columns = list(time_shifted_df.columns)\n", + "treatment_columns.remove(target_node)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -178,7 +189,7 @@ "model = CausalModel(\n", " data=time_shifted_df,\n", " treatment=treatment_columns,\n", - " outcome='V6'\n", + " outcome=target_node\n", ")\n", "\n", "identified_estimand = model.identify_effect()\n", From 0fc85cc0f5b5023eb97341730db3afc1af70a54a Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Tue, 30 Jul 2024 04:16:52 +0000 Subject: [PATCH 47/67] formatting changes --- dowhy/timeseries/temporal_shift.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 22055f18a..3d2e75d49 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -3,6 +3,7 @@ import networkx as nx import pandas as pd + def find_ancestors(graph: nx.DiGraph, node: str) -> List[str]: """ Given a graph and a node, this function returns the ancestor nodes of the node that are not parents. @@ -20,6 +21,7 @@ def find_ancestors(graph: nx.DiGraph, node: str) -> List[str]: ancestors.append(n) return ancestors + def find_lagged_parents(graph: nx.DiGraph, node: str) -> Tuple[List[str], List[int]]: """ Given a graph and a node, this function returns the parent nodes of the node and the time lags associated with the edges between the parent nodes and the node. @@ -42,7 +44,12 @@ def find_lagged_parents(graph: nx.DiGraph, node: str) -> Tuple[List[str], List[i def shift_columns_by_lag( - df: pd.DataFrame, columns: List[str], lag: List[int], ancestors: List[str], filter: bool, child_node: Optional[str] = None + df: pd.DataFrame, + columns: List[str], + lag: List[int], + ancestors: List[str], + filter: bool, + child_node: Optional[str] = None, ) -> pd.DataFrame: """ Given a dataframe, a list of columns, and a list of time lags, this function shifts the columns in the dataframe by the corresponding time lags, creating a new unique column for each shifted version. @@ -77,12 +84,11 @@ def shift_columns_by_lag( relevant_columns = ( [child_node] + columns - + [f"{col}_lag{shift}" for col in columns for shift in range(1, int - (lag[columns.index(col)]) + 1)] + + [f"{col}_lag{shift}" for col in columns for shift in range(1, int(lag[columns.index(col)]) + 1)] ) relevant_columns = list(dict.fromkeys(relevant_columns)) # Ensure unique and maintain order new_df = new_df[relevant_columns] - + for ancestor in ancestors: new_df[ancestor] = df[ancestor] From f87f74d14db4e1fa53c09519c006aea92ea34a7b Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Tue, 30 Jul 2024 04:20:16 +0000 Subject: [PATCH 48/67] comments : notebook --- .../timeseries/effect_inference_timeseries_data.ipynb | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index 20a3821bc..1841ad359 100644 --- a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -161,6 +161,7 @@ "metadata": {}, "outputs": [], "source": [ + "# inlcude specific treatments\n", "treatment = 'V7'\n", "treatment_columns = [treatment] + [f\"{treatment}_lag{i}\" for i in range(1, int(time_lags[parents.index(treatment)] + 1) ) ]\n", "treatment_columns" @@ -172,8 +173,10 @@ "metadata": {}, "outputs": [], "source": [ + "# include all the treatments\n", "treatment_columns = list(time_shifted_df.columns)\n", - "treatment_columns.remove(target_node)" + "treatment_columns.remove(target_node)\n", + "treatment_columns" ] }, { From cdbb9af4cdb805e1c49d7ed887e9485fdd9f732d Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Wed, 31 Jul 2024 04:58:00 +0000 Subject: [PATCH 49/67] multiple time lags : csv graph' --- .../datasets/temporal_graph.csv | 4 +- .../effect_inference_timeseries_data.ipynb | 154 +++++++++++++++--- dowhy/utils/timeseries.py | 23 ++- 3 files changed, 156 insertions(+), 25 deletions(-) diff --git a/docs/source/example_notebooks/datasets/temporal_graph.csv b/docs/source/example_notebooks/datasets/temporal_graph.csv index 35cb047ed..59048d5be 100644 --- a/docs/source/example_notebooks/datasets/temporal_graph.csv +++ b/docs/source/example_notebooks/datasets/temporal_graph.csv @@ -3,4 +3,6 @@ V1,V2,3 V2,V3,4 V5,V6,1 V4,V7,4 -V7,V6,3 \ No newline at end of file +V4,V5,2 +V7,V6,3 +V7,V6,5 \ No newline at end of file diff --git a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index 1841ad359..cf8870242 100644 --- a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -50,9 +50,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from dowhy.utils.timeseries import create_graph_from_dot_format\n", "\n", @@ -79,9 +90,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAboAAAGFCAYAAACL2zb9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAADVGUlEQVR4nOydd3ib13nofwBIkMQkSBDce1OckihRw9qyLA/Zlu14ZDppGtd10qRNbjOcm7Rp0ySNc++t07RpnDjDjlfiWLEl2doSZUmURImkSHHvPQESAAFi3j/c76tkDUs2RYDk93sePBpY7/fhnPOe806Z3+/3IyEhISEhsUCRB1oACQkJCQmJW4mk6CQkJCQkFjSSopOQkJCQWNBIik5CQkJCYkEjKToJCQkJiQWNpOgkJCQkJBY0kqKTkJCQkFjQSIpOQkJCQmJBIyk6CQkJCYkFjaToJCQkJCQWNJKik5CQkJBY0EiKTkJCQkJiQSMpOgkJCQmJBU1IoAUIBELDBq/Xi9/vx+fz4fP5xOcv/btMJhP/FB5yuVx8CM9LSCxWhPkkzCOfz4ff77/s/wWuNp9kMhkKhUKcWxISs82iVXQ+n4+xsTGsVqv48Hq9+Hw+bDabOFkjIiIICQkhJCSE8PBwVCoVKpUKo9GIVqslNDQ00JcjIRFwfD4fZrMZu93OxMQENpsNj8eDz+fDbrfj9Xrxer2Eh4cTGhoqzqfw8HAiIiIwmUyo1WoiIiICfSkSC5AFp+h8Ph8ej4f+/n4sFgujo6MMDw8zOTnJxMQE4+PjOBwO8eF2u8WHsAO99O8KheKyE5yg9MLCwoiIiCAsLAydTkd0dDQ6nQ6j0YjJZMJgMBATE4PJZCIkJEQ6+UnMS/x+P263m/HxcSYmJhgYGGBiYoLJyUlxXk1PT2O1WpmZmcHtduNyucQ55Pf78Xg84t8vPbkpFArxER4eTlhYGGFhYURGRqLT6dDr9cTFxWEwGIiMjCQxMZGoqChRGUpzSuJGmbeKTlBELpcLl8vF9PQ0TqeTmZkZbDYbbW1tjI2NMTQ0xODgoKjoxsbGcDqdOJ3Oy8yQwgQELjOfCBNUeAimGa/Xi1wuJzQ0VFRwOp2OmJgYYmNjMRqNJCQkkJ6ejkqlukwxhoeHS8pPIqgQ5pPH48HlcmG323G5XMzMzDA1NcXAwABDQ0P09PQwPj6OxWJhaGhIVHR2u/0yM6RCoQCuNFEKlhJA/LuwORXeGxkZiV6vR6fTER8fT3R0NAaDgYyMDBISEtDr9URERBAeHo5SqUSlUhESEiKZPSWuiWy+dhgXFE9zczNdXV2cOHGC2tpaenp6aG5uxuVyERISglarJSsrC5PJRFJSEunp6ej1evR6PbGxsWi1WrRaLZGRkaLSU6vVouITTn1er1dUona7ndHRUSYmJpiammJ0dJTOzk5GRkbo7e2lo6MDh8OB1+slKiqKpKQkcnJyqKioYMmSJSxZsoSEhARpYkoEDcJ8GhwcpKOjgyNHjtDa2kpbWxt1dXXMzMzg9/vR6/UkJiYSGxtLVlYWCQkJGAwGjEYj0dHRaLVaDAYDOp2O0NBQZDKZqIgUCgUOhwOPx4PH42FmZgaHw4Hdbmd4eJipqSkmJycZHBxkaGiI4eFhWltbGRgYwGKx4Ha70el0REVFUVZWRklJCVlZWaxduxaTyUR4eHigb6NEkDKvFJ3L5aK9vZ3Gxka6urq4cOECg4ODTE9PI5PJiIqKEk9XaWlpGAwGoqKi0Gg04klKrVYTEhJCaGgoYWFhoilSmJSXOsbhfwJWLt15CkrP5XJdtgMWJq7VahVNO93d3UxOTjI5Ocno6CihoaGoVCpyc3NJT08nPT2dVatWodVqpYkqMaf4/X46Ojro7u6mqamJmpoaRkdHGR8fRyaTodFoxA1hfHy8aK0QLBNqtVo8VQkPYS5desK61Hpx6SlOsIwI88ntduPxeESLy8zMDHa7XTwx9vT0MDQ0hNlsZmxsDLPZjNfrRa1Wi6e9goICli9fTlRUFFqtNpC3VyKICGrTpTARzGYzU1NTWCwWampqaGxspKenh7a2NrxeL2FhYSQnJ5OTk0N8fDzZ2dnk5eVhMBgwGAwfSYaQkJu7RcIknpqaYnBwkIsXL9Lf3093dzcOhwOz2czo6Ch2u52hoSH6+/uRyWTExcURFRVFdHQ0KpUKpVL5keSWkHg/wti0WCzY7XYsFgu1tbV0dXXR3NwsWkIA0tLSSEpKIjk5mcLCQlJSUoiLiyMmJuYjmdwFk+bN4PP5mJmZoauri87OTgYGBmhqaqKtrY3R0VG6u7uxWq309fUxNjaG2+0mISFBNHsKQWQSi5egPtEJ/oHXX3+dI0eOcP78eZqbm0lOTiY1NZUtW7awatUqMjIyyMzMvOpnBMIPdq1b6na76erqoqmpiX379olKe2pqisLCQoqLi3n00UcpLi4mISFhjqWWWOh4PB4cDgdvvfUWZ8+eZd++fbS0tKDRaEhJSeGOO+6gsLCQ0tJScnNzr6qUgmk+eTwezGYz1dXVVFZW0tDQwIkTJ7BarZhMJsrLy3nkkUcoKChgyZIlcyy1RDARdIrO7XbjcDg4cuQIp0+fpq6ujq6uLtEPsHLlSvLz80lISBBNlREREURERAR1cIdg/nQ6nUxPTzM+Pi4GyJw+fZr29nYGBgYYHx8nLS2NjIwM7r77bpYsWYLRaASkKDOJm8fr9eJyuTh58iQNDQ0cOnSI3t5eFAoFMTExrFixgvT0dHJzc4mOjkatVqPRaFCr1UE/3gRXgtVqxWKxYLPZGB8f59y5c3R3d9Pa2sr4+DiRkZFkZGRw7733kpOTI26Kg/36JGaPoDBdCkpgeHiY4eFh+vv7OXr0KG1tbQwMDBATE0N2djaZmZls3LiR9PR0oqOjAy32TSH4/y7NwxN8E2q1mujoaJqamjhz5gz9/f1MTk6iUqmwWq2kpaWRmpoqOvUlJK6HsHcVUgI6Ozs5efKk6I8TwvYLCgpYv349qamppKamBljqm0cul6NUKomOjiY6Olp0deh0OlpbWwkLC+Ps2bNMTk5SV1dHZGQkIyMjTE5OkpGRIUZDSyx8An6iuzRN4Pe//z3vvPMO+/fvx+PxsHr1atatW8dnP/tZ9Hr9gg/WmJmZ4eLFi7z++uu8++67HDlyhKysLEpKSvja175Gbm4uOp1OfL20I5V4P5eG7u/Zs4fjx4/zy1/+Eo/HQ0pKCvfeey+f+MQnSExMRKPRBFjaW4vf7+fixYucOnWKN954g4MHD6LX68nOzuYf/uEfyMnJucxFIM2nhUtAFZ0Q9VVVVcXbb7/NmTNniIuLIzs7mwceeID4+HiMRiMxMTFi4vZCxufziQEr4+Pj1NXVsX//ftrb25mammLz5s0sW7aM++67D5VK9aEc+xILm/7+ftra2nj++edpaGjA6/VSXFzMHXfcQXp6OomJiURHR6NUKhf8+PH7/WL6wvj4OLW1tZw7d46TJ09isVgoLCxkxYoVfOpTn0Kj0UgBYAuYObeDCXrVarUyODjIkSNHqKuro7W1lcTERAoLCykvL6e8vHzRDT4hh0+tVmMymdBqtTgcDnQ6HadOnaK5uRmn04lGo6GsrEzMW5JY3AjVS7q7uzl37hwXL16kqakJrVZLfHw869evp6KiQkwNWCy831VwqS//2LFjDA0NcfLkSRISEsjNzSUlJYXIyEjpZLcAmdMTnfBVfr+f+vp63nrrLf7f//t/hIeHk5ubyz/+4z+Snp5ObGzsXIkU9Pj9fsbHx3n77bf5xS9+QXt7OyEhIXz3u99lxYoV5OfnA5LZZTFy6XyamJjgV7/6FS+//DJdXV0UFxfz13/91yxfvpz09PQASxo8CJuCXbt2sXv3bvbt24dSqeSxxx7jvvvuY9myZVKx9gXInCo6t9uN3W7nmWee4dy5c1y4cIG77rqLiooK1q1bR2xsrJh0KvEefr8fr9eLzWajp6eH+vp6fvWrXzE0NERKSgoPPfQQ991330fOF5SYfwgFyF955RUOHz5MZWUlq1evpqysjI997GNER0cTERGxqKwiH4Sw3AkVjXp6enjmmWcYGhrC7/fzV3/1V6xbt47c3NwASyoxm8yJRhHC6gcGBjh9+jTV1dXY7XbKyspYv349hYWFpKWlAdLJ5P3IZDJCQkKIjIxEqVQSFhbGwMAABw8exOFwcODAAdGvmZGRIUZ3SixsXC4XU1NTHDp0iFOnTtHd3U1JSQlr1qyhrKxMPMVJY+FyhPshBLfp9Xpuv/12zp49S3t7O4cOHUIul+N0OikqKpLm0wLhlis6YQc1MTFBVVUV//zP/4zT6eS2227ji1/8IoWFhVKI7w2iUqnIycnhb//2b0lKSuLQoUP89re/xePxsGXLFpKTk1Eqlfj9fmlyLlAu9XF3dHTw/e9/H7vdjslk4n//7/9NVlYWUVFRAZZyfhAWFobRaORLX/oSlZWVHD58mB/96EcMDQ3R2dlJTk4OSqVSDIKT5tT85ZabLh0OB8PDw3zjG9+gpaUFj8fDP/7jP7JkyRJxYZYG0I0j/FxC7b9jx47x05/+lPDwcFatWsXTTz+N0Whc8BF1ixWv10t/fz/PP/88b731Fk6nk8cff5wtW7aQk5NDaGio9NvfBMJ8cjqdWCwWdu/ezeuvv05TUxPbtm3j8ccfl/x2C4BbeqJzOp309vaye/du+vr6iIyMZO3atRQWFhIXFyed5D4EwmTTaDQkJiZSUVHBhQsX6Orq4syZMxw7dozCwkLy8vIue73E/MflcmG1Wvnzn/9MfX09Ho+He++9lxUrVpCWlkZYWJj0e98kwv0SGiyvWLGC0dFRwsPDqa6uJjs7G5/Px8qVKyVLyTzmlig6YZdksVior6/npz/9KTExMaxatYqvfOUraLVaadc5C+j1ekpKSviLv/gL9uzZwzPPPMOrr76K1WolMzNT6n6+QLj0FN/b28t//ud/olQqSU9P58tf/jI6nU4KOJkFQkNDKS4uRqVSkZWVxRNPPMGePXsYHx+nrKxM7HAiMf+4ZYrO6XTyL//yL5w5c4bQ0FC+/e1vU1ZWhk6nkwbLLFNYWIhWqyUlJYXvfOc7jI2NMTU1xec//3nUanWgxZOYBZxOJ3/4wx944YUX8Hq9PPbYY+zcuRODwbDgCynMNWlpaURFRfHss8/y3HPP8eqrrxIZGckDDzxARkZGoMWT+BDckhkyOTnJwYMHaWxsBODhhx8mNzeXqKgoydY9y8hkMkJDQzGZTCxbtow1a9YQFhbGvn376OjowGw2B1pEiY+Ix+Ph2LFjnDt3jpGREe6//37Ky8uJi4uT5tMtICQkBI1Gw7Jly1i1ahVZWVns27ePxsZGhoaGAi2exIdg1hWdx+NhdHSUP/3pTwwODmIymfjc5z5HcnLygq9VGUh0Oh15eXns2LGD+Ph4jh8/Tl1dnZgfFGRNKiRuEK/Xi9Pp5K233qKhoQG5XM6nP/1pli5dikqlkpTcLUKpVJKbm8vWrVtZvXo1lZWVnD9/no6ODmk+zUNm3XRZW1vL8ePH+f3vf8/f/d3fsX79ehITEyXzyhwgk8m49957iYiIYHx8nO9///s8+uijfPGLX7ysGLTE/KGnp4fz58/z8ssvs3HjRp566inS0tIkn9wcsWbNGhISEqiuruZPf/oTtbW1LFmyBLVaLRW2mEfM2i8lVPA4deoUZ86cIT8/n2XLlpGXlzdngSfj4+O0t7fzxhtvXPGcUqlEp9Pxuc99Dr1ef4XsMzMzHDx4kHffffeK9z700EOUlZWJ/3Y4HPT09HDq1CmGhoaYmpriiSeeIDk5edav6WaQyWTiTnTnzp18//vfp7W1lcrKSm6//XZpcZxHCN3AW1pa2Lt3L2lpaZSUlMxpUITVamV0dJTf/OY3uN3uy56Ty+VERkZyzz33XLWKyMzMDC0tLbz00ktXPLd8+XJ27tx51e90Op386U9/or+/H7vdzpo1aygoKAhYI+LQ0FBiYmL42Mc+xi9+8QsGBgY4fPgwa9euFftESgQ/s6bohHJEZ86cob6+noqKCpYsWUJKSspsfcUHMjU1RXNzM7/61a+w2Wy43W5cLhcRERFERUWRlpbGI488coWig/dCt6uqqnjuueeYmppCoVCgUChQqVQsXbqU0tJSvF4vDoeD8fFxampqePHFF2loaGB4eJh777034IpOICUlBZ1Ox7//+7/T19fHkSNHWL9+PSEhIdLJeh5hs9loaWnhyJEjrFu3jtLSUrKzs+fs+x0OB4ODg/z2t7/FbDYzMzOD0+lEqVSiVqvJzs6mrKzsqorO7XbT1dXFr371K6xWKz6fj5CQECIiInA6nVdVdG63m8nJSV5++WVqa2sxm834/X6io6MDpujgPbfAnXfeyZ49e7h48SIHDhygoKAAg8EgRY/PE2ZN0VksFl566SXq6+sJDw/na1/72pwPztTUVJKSkti5cyc//OEPOX78OIcPH+bRRx9l06ZN7Ny585q5e1qtlqeffponnniCp556ioSEBHJycnj88ceJiIjA7XbT19fHb37zG86fP8/AwAD9/f1YrdY5vcYbQalUEhUVxec+9zn27dvHiy++yGc+8xmSk5OvquQlgg+v18vrr79OZWUlk5OTPPnkk3NenDkmJobo6GgaGhp47bXXeOutt3j99dfZtGkTGzZs4Kmnnrqm312tVrN9+3ba29v5X//rf2G1WsnNzeUzn/nMNU9CjY2NnDx5koMHDzI9PR00nTnkcjl6vZ6dO3diNBr55S9/yebNm4mMjMRkMgVaPIkbYFa2936/H6vVyv79+4mJiWH58uWYTKY5z+OSy+WEhoaKp7CCggLgvQnU29t7zYRaoZ6d3+/H5XLR1taG0WikvLxctMVbrVbefPNNXC4XRUVFfOUrXyEjIyMoc9VkMhkKhYI1a9aQm5tLaGgo7777Lj09PYEWTeIGENwAx44dw263s3r1auLj4+c8VUQYR0LpuRUrViCXy+np6aGxsZGwsLBrWgiEeeb1eunu7sbj8bBmzRoMBsMVm02/38/U1BTV1dW8+eabFBYWBpUCEdaH4uJili9fTnh4OHV1ddTV1QVaNIkbZFYUncvlwmw2U11dTVxcHCUlJWg0moA6a3Nzc8nMzCQkJIS2tja6u7txOBzXjZay2+2Mjo4yOjpKZGQk2dnZ4oR1uVy0t7djMBgoKyvj4YcfJjExMWgd0jKZjLy8PNLT04mMjKS6upq+vj4pYmwe4PF4sNvt1NbW4vV6WbFiBZGRkQGtJJSUlMSSJUtQKpUMDg7S0tLC9PQ0Xq/3mu9xuVzifAIoKCi4qp/Y5/PR19dHU1MTFy9eZMmSJUGl6ATS0tLIzc3FZDLR0tJCY2OjNJ/mCbOi6FpaWjh79iwDAwMsX76czZs3z8bHfmhkMhm5ubkUFhaSmprK5OQkra2tnDx5kpmZmWu+r6GhgQMHDlBeXk5WVhbR0dHicyaTiX/+53/my1/+Mvfffz8KhSLoQ7tDQkLIz8/nzjvvFPOAPB5PoMWS+ACGh4c5efIkvb29xMfHs3PnzoAHEiUlJVFaWkpaWhper5eenh5OnjzJ+Pj4Nd8zPDzMG2+8QXp6OsXFxcTExFzVp+Vyufj+979PT08P27ZtY+3atQH1yV0LhUJBbGwsO3fu5OLFixw/flyaT/OEWVF0ra2tNDY2kpmZSUpKSlDsxuRyOUajkXXr1qFSqRgeHqayshKn03nN93R0dFBdXc3q1atJTEy8rEWHXC4X6+HNByUnyJ6SksLq1avF8lEtLS3SDjTIGRkZ4fTp08THx5OWlkZCQkLAg4hkMhnh4eGsXbuW2NhYHA4Hx44dE09rV2NiYoKjR4+Sm5tLQUHBVVve9PX1UVlZSWdnJykpKTz44INBW+hdJpOh0+nYsGEDCoWCkZERLl68eN01RSI4mJXZ09/fT09PD2lpaRiNRjQaTVAM1MjISJYuXUp4eDhms5mamhqcTic+n++y1/n9fjHCrKuri6Kioisc5kJfuEAvODdLVFQUOTk5yGQyJiYm6OnpueL6JYILs9lMU1MT8fHxxMXFodPpgmLcKZVKysrKMBqNzMzMcP78eSYmJvB6vVdsnmZmZpiYmKC5uZm0tDSx36SA0Om7t7eXqqoqQkJCSEtLo6ysLKgjGVUqFfn5+YSHh2O32+ns7LyulUgiOJiV2dPV1UVXVxcVFRVB1ek6Li6Oe+65B51Ox/DwMIcPH2ZsbOyKHZjX66WhoYHu7m6mp6eD1nTyYdBoNCQkJJCcnIzNZqOurk5SdEHO2NgYtbW1FBcXk5qaGmhxRMLDw7nrrrtITU3F4XBw+PBhcc68n/b2dlpaWpiYmKC0tFQMDLuUsbExDh8+zH/8x3/w5S9/mW3btqFSqebiUj40oaGhxMfHi5Wezp07h8PhCLRYEh/AR1J0Pp9PbElvtVrJy8tDo9HMlmwfGaVSidFoZMmSJSQmJuJ0OqmqqqK9vf2y1wm1BOVyOatWrbqs2eJ8R4icy8nJwe/309bWJpkugxS/34/NZmNiYoLh4WHS0tKCwg0goFAoMBqNZGVlkZubi9vtpqGhgXPnzl3x2rNnz9Lb28v69evR6/VXzCev18uvf/1rurq6WLt2LaWlpcTGxs7VpXxoBPNramoqUVFRNDc3S6bLecBHVnQ2m01Mzo6Pjw+qepYKhYKIiAiysrJISEjA6/Vy8eJF+vr6xNcIJpS6ujoUCgVFRUWEhIQEhel1tpDL5cTFxQHv+X8kRRe82O12bDYb09PTmEymoCrdJpPJiIiIIDk5mczMTHw+H52dnTQ3N4uvubSiy+joKGVlZahUqssUncPhYGRkhLNnz+JyuVi5ciWxsbHzqtOG4KIZHBy8omqMRPDxkRSd1+tlcHAQh8NBaGgoqampREREzJZss4JMJmPDhg2UlZXh9/s5ePAg9fX14vNCKPehQ4eIiIjg9ttvD2ofwYdBJpORlJSETCZjeHhYUnRBzOjoKJOTk8B7kY7B5AoQKCkpYdOmTchkMqqrqzl69Kj4nM/nY2ZmhqqqKvr6+tixY8cVRQq6u7vZtWsX7e3tpKWl8cQTTwTduvFBmEwm9Hq9pOjmCR8pCUwwXbrdbuRyOTqdLigTqMvKyujs7ESlUtHZ2Snm1SUlJdHX10ddXR0xMTGkpKSQmpq6oE5z8J6iE6pMWK1WSdEFMVarFYfDIf5mwWQhEcjOzsblcqHRaBgZGaG1tZWuri7i4uJwOp2cOXOGsLAw4uLiSE9PF1Mj/H4/ExMTnDlzhl//+td84hOfoKKiIiiv8YNQq9UolUqmpqYkn/c84CMpOqEYstfrRS6XX7dSQiAxGo3Ex8eTkJBAZ2cnQ0NDtLe3ExcXx/DwMI2NjSQnJ2MymeaV+eRGEULDASlCLIgRKvMIJwSlUhmUBQl0Oh1xcXEkJCTQ19fHxMQEbW1taLVaZmZmqKurQ6/Xk5SUdIXPfmhoiM7OTpqamrDb7XR3d192InK73Vy8eJGJiQk8Hg+dnZ2cPXsWi8UCvKdkjUbjNasczRXCb3O1KG6J4GNWFJ3P50MmkwWlohMakyYmJrJhwwaGhobo7u5m3759lJeX09HRwZEjR7jjjjvIzMwMtLi3DEHROZ1O6UQXxLhcLjEJOVgVXUhICDqdjo0bN/LOO+8wNTXF3r17SU5OxuPxsGfPHjZs2MDSpUsve5/f7+f8+fM0NzczNTXFd7/73Q/8rt/+9rf89re/Ff/9//7f/+O+++4LeAH1sLAwUdFJ8yn4+UizSC6Xo9VqCQkJwefzYbVa0el0Aa/icDUSExO566672LVrFz09Pezbt4/HHnuMtrY2Wlpa+Jd/+ZegCuWeTYRapPBe8eqFZppdSKjVanFTYrPZcDqdQWll0Gg03HXXXdTV1dHf38/bb7/NbbfdRmhoKPX19fz1X//1FYpOJpNxxx13UFFRwRe/+MWrfq7b7ebo0aPs3r2bCxcu8Mgjj7Bu3TpycnKA98pwBYPf0m63MzMzEzQ5jhLX5yMpOiEKS1B009PTQTkp4T1zS3Z2NpGRkQwODtLX10dVVRWDg4NoNBri4uKCKjVithFyneab038xIZiYhY2iw+EI2kCH0NBQsrOziYmJQalUMjAwwPnz59FoNKjVakwm0xUKSSaTYTQaxRSFq+F0Ounv7ycyMhKFQkFSUhJFRUWX9YMMBpxOJ263+4qIUongZNZOdF6vl8nJSSIjI4NyMRUUXWpqKlNTU4yMjPCzn/0Mk8lEeXl50J5EZwOhOjwQNFVrJK6ORqMhPDxcPIUHa46WUqkkJyeHtLQ0YmJi6Ojo4JVXXiE2NpaKigpMJlNQrgOzhc1mY2ZmBq1Wu+CitBciH2krEhISQkpKCnq9Hr/fT1NTEzabbbZkm3Xkcjlbt26luLgYn89HU1MTOp2Ou+66KyijRWcLr9dLc3Mzfr+fjIwMSdEFMQkJCcTExBAaGkp7ezsjIyOBFum6lJeXs2HDBuC9CkmTk5Pcd999REVFBVawW0x3dzdjY2NkZ2cHtKuExI0xK6bLyMhIVCoVvb29QV0ORyaTsWTJEpqbm8UKB0ajkZycnA/clbndbkZGRqivr2dsbAx4b7DPzMzg9/t55513aG1tBaC4uBiTyRQUlR6EBN6BgQH0en1QFAiWuDbh4eFotVqioqIYGhoSow2DlfT0dPLz88X5JNSCvJlSXl6vl9raWoaHhxkeHqa6upqBgQHcbjcXLlxAqVTS0tJCTEwMS5YsCei8EgJPRkZGsNlsYr9HieDmIyu60NBQTCYTMTExtLS0YLfb8fv9QXlqkMlklJeXi13QY2JiSE9PFyurXw+n00lNTQ3f//73OX369GXPyeVy/vEf/1H8jm9/+9usW7cuKBQdvLeQtLe3s3z5culEF8QIhcP1ej0pKSl0dXWRn58vLq7B+Lvl5+fjcDgICwvDYDCQmJhIYWHhTcnqdrt5+eWXOXr06BXlxP785z/z5z//GZVKxZo1a/j6178e8Hkl9M+zWCzk5OTMyzzAxcasxC5nZ2czMDDA4cOHefDBB/H5fMjl8qCcmFFRUfzlX/4lDz74IAqFAr1ef0NyqtVqNmzYQGlp6XX9JjKZDIPBEDSDf3BwkMbGRsxmMzExMSxbtkw60QU5sbGxlJeXc+jQIbKyssT5FIxotVpWrVpFQ0MDcrmc8PDwm573YWFh/P3f/z1f+tKXrpnnKXx2ZGTkLEj94bHZbFy8eJGhoSHCw8OpqKgI+kLUErOk6NLS0hgYGOAPf/gDAwMDjIyMiLUVgwmhwHFkZORNTxi5XI5arQ7aqNJrMTIywoULF9Dr9cTFxREfHx+UGxCJ/yE6OpqSkhLeeOMNhoaG6O/vJzExMSiDHoR6shkZGR/6M2Qy2WVNjoMZu93O+fPnUSgUxMTEkJiYKJku5wGzsk3Mzs6muLgYq9VKW1vbFd0BJOYev9+P3+8X+30lJSWRkpJCXFxc0J4OJN5DiFx0uVz09fVx8eJFvF5voMVa9Pj9fiYnJ6msrESj0ZCenk5CQsKCjdZeSMzKihcdHU16ejorVqzg7NmzvPnmm7PxsRIfkZGREWprazly5Ah33333VXuCSQQfGo2GlJQUli1bxuTkJL/73e+k0m1BwMTEBO3t7ezdu5eysjLWrVsXaJEkbpBZUXSCr2vTpk1MT0/T2NhIV1dXUEdgLnS8Xi8nTpygs7MTpVLJsmXLFkwz2YWOXC4nNDSUtWvXYjAYaGhooKOjA7PZHGjRFjUXLlzg/PnzyOVy8vPzyc3NDbRIEjfIrNmwNBoNd9xxh9jcs66uDpvNJtWBCwA+nw+3282BAwfo7u4mJiaGsrKyoPSbSlwdhULBxo0biY+Pp6Ojg/r6erGXoDSn5ha/34/H46GqqoozZ85gNBopLCwUy5JJBD+zpuhUKhUrVqxgw4YNJCQk8E//9E+0tbUFbQmjhczY2BjV1dXs2rULlUrFl770JXQ6XVAGM0hcHZlMRllZGbfddhurVq3i3/7t3zh8+DAulyvQoi06HA4HNTU1vP3227S2tvLVr36V9PT0oCy4LXF1Zk3RCTl1q1evZu3atQwPD3P8+HHOnDkzW18h8QEIbV6am5v54x//SFRUFPn5+SxfvnzBdU1f6Ag5dbm5udxzzz1YLBZqamo4ePCgFJgyh7jdbkZHR3n55ZfxeDxkZmZSUVEhFUefZ8x6+N3y5ctZvXo1AKdOneLEiRNSz6Y5QDBnmc1m6uvr2b17NxkZGRQVFZGfny9FWs5TMjIyuP3228XqIPv27cNut4utfCRuDYKJ2Gaz0dPTI1pHiouLWbJkiZQ7N8+Y9bN3VFQUpaWlfO973+PHP/4xnZ2dpKens2nTpgVf/y7QeDwevv/971NTU4PL5eI73/kOaWlpgRZL4iOgVqtJTU3lW9/6Fq+99hovvPACy5cvZ+XKlWRnZwdavAWN3+/nd7/7HQcOHMBms/H444+LdT0l5hezruhkMplYLWHNmjW0tbXx61//msjISPLz80lMTJztr5QAenp6ePfddzl9+jQGg4FPfepTJCYmolarJRPLPEYwYZaXl9Pf34/ZbObll1/G4XAgl8ulkm63CJvNxt69ezl27BjDw8M8/vjjFBQUEBkZKd3vecgt8aZGRESQk5PDqlWr8Hg8vP7662JTxujoaJRKpWRKmwUEc6XVaqWlpYU9e/YwNjZGQUEBO3bsIDIyUkpmXQAoFAoyMzNZtmwZo6OjPP/88yQkJGAymYiPjycsLEwKNJoFhPnkcDgYHBxk9+7ddHZ2EhERwb333ktKSkrQlPaTuDlk/lsYq+zxeKivr+eHP/whJ0+eJC8vj2984xssX7583pXSCkYEP8L//b//l6NHj7Jv3z6eeeYZVq5cSVlZmVhRXmJh4PV6sVgsfPWrX6WmpgabzcZ//Md/sGTJEuLj4wMt3rxHWApff/119u3bx69//Wueeuop7rjjDjZv3izNp3nMLVV0fr8fs9lMbW0tP//5zxkeHkaj0fCFL3yB/Px8MjMzb9VXL2iE1jtdXV3s27ePV199FYVCQW5uLl/4whdISkqS/KELEL/fj9vt5tSpU7z11lucOnUKrVbLPffcw6pVqyguLpYW4g+J1+vFZrPx6quvcujQITo6OigrK+O+++6jpKSEuLg46d7OY25pIohMJiMyMpK1a9dSU1PDyZMnqayspKioCI/Hg06nw2AwoFAopEF0g/h8PrxeL0NDQ9TX17N3716Gh4cpLCzkzjvvJCsrS4oIW6AIKTyrVq1ibGyMqakp/vznP2MymQgJCSEuLg69Xi82ApXm1AcjJIObzWZ6e3t5++236e7uRqFQcOedd1JUVCSdlhcAt/REB/9jDvD5fFy4cIHf/OY3vPDCC8THx7Njxw6+9KUvER0dLfkYbhCn08nw8DDf+c53OH/+PN3d3TzzzDOUl5dTVFQESAvcQubS+WQ2m/nhD3/IO++8w+DgIJ/73Od45JFHKCwslDaPN4jX66W/v58XX3yRXbt20dzczOc//3l27NjB6tWrJXPlAuGWKzr4n8k5NTVFd3c3r776Ks3NzbS2toqVHzZv3ozRaJQU3nVoaGigvr6e1157jb6+PmJjY9m2bRtbt27FZDKh1+sDLaLEHCGYMZubmzly5Ajnz5+nurqa0tJSioqK+PjHP05UVJR4upO4kt7eXlpbW3nuuefEjuYPP/wwK1asIDs7m6ioKEnJLRDmpIaNMFj0ej1FRUWMjY0RFhZGZ2cnVVVV+Hw+8bnIyEg0Go20k/pv3G63eIo7c+YMNTU1nDt3jtzcXIqLi9m2bRvJyclSdOUiQyaToVQqRTeAWq3mwoULNDY2YrFYyM3NJTs7G6PRKC7Y0nx67wTndrsZGBigoaGB8+fPc+7cOWJiYsjNzWXbtm3Ex8ej0+kCLarELDInJ7r3I/R16u3t5Stf+QptbW2YzWb+6q/+is2bN7Nu3TqUSqU0MYHh4WEaGxt55plnOHXqFEqlkrvuuouvfOUrZGRkiApOuleLF6H0W0dHhxiB29PTw8MPP8y6det47LHHCA0NlVJ6gMnJSQYHB/nud78rmv4fffRRHnzwQTZt2iSmD0jzaWEREEUH/3NSaWxs5MKFC5w6dYrq6mqioqJIS0vjgQceIC8vj9TU1EW3G52enmZsbIz9+/dz7Ngxuru7sdlsbNy4kYKCAlauXElqaioRERHS4iUBvOezczgcdHZ20tHRwZ49e2hoaMDtdpOTk8Mdd9xBfn4+xcXFyOXyRTWfXC4XNpuNt99+WzTxWq1WCgoKWLZsmViI3mAwLLp7s1gIWPnt0NBQQkJCWLp0KTqdDqVSSX9/PxaLhfr6emJiYpiYmGB8fJzExER0Oh0RERELVum53W5cLhcjIyP09/fT29vL8ePHaWtrw+VykZ+fz9q1aykoKJBKP0lcgVwuR61Wk5+fT2xsLHa7HbvdTldXFw0NDeh0OsbHx3G5XMTHx6PVatHr9Qt2PgkmypGREcbGxujr6+P48eN0dHQwMjJCUVERK1asYN26dRQUFEixAQucgJ3o3o/P52NoaIjDhw+ze/du3njjDbRaLUlJSTzxxBNUVFSQk5NzmS9qPk/Q9992i8XCwMAAv/vd79i/fz+tra2Eh4fzwAMPcNttt/Hggw8SEhIineAkbpjR0VGam5t57rnnxGLQ8fHxfPazn2XZsmWsWbPmMhfBQppPDoeD0dFRXnzxRU6ePMmRI0cIDw9n5cqVbN++nU9+8pOo1WpJwS0SgkbRCVFkk5OTTExMcPHiRc6dO8eFCxdoaWlBr9djMpnYsGEDy5YtIyMjg8TExHk5Of1+P16vl97eXjo6Oti/fz9NTU309fUxMzPDkiVLyMnJYevWrcTHxxMZGSkFFEjcNG63G4fDwcjICK2trbS1tXH06FHa2tqQy+UYjUY2bNhAfn4+paWlJCcnz9sea16vF7PZTFNTE0eOHKGtrY2GhgZmZmaIj49nyZIl3HHHHcTHxxMTE0NMTIxkplxEBM2oFqLIYmJiiI6ORq/XExERgVqtxu12MzU1xcjICKdPn2Zqaoq2tjYyMjKIiopCo9EQFRWFWq0Oyr5rQpK3xWLBarUyOTnJ8PAwPT09dHd309DQwOTkJKGhoWRnZ7NixQqWLFlCeXk5oaGh0q5T4kMRGhpKaGgoWq2WyMhITCYTHo8HmUzG+Pg4ZrOZc+fOMTo6yvDwMFlZWURGRqLT6YiJiSE8PDwogzOEjeLU1BR2u52JiQnGxsYYGRmhqamJixcvMjExAUBOTg45OTmsWLGCFStWoNFo5q0yl/jwBM2J7lp4vV7GxsY4ceIEZ86c4dVXX2V4eBi32016ejqrVq2ioKCA9evXk5WVhVarvaZiuJWT9Xq30eVyMT09zalTp6ivrxcbaE5NTeH3+1m1ahXr1q2jvLyczZs3S8pN4pbh9/uZmJigtbWVQ4cO8dprr9Hf38/4+DgZGRnk5eWxdOlSbr/9dlJSUoiPj7/uWLxVc+p688nr9WK326mrq6O1tZWjR49y4sQJhoeHsdvtlJeXU1xczO23386mTZvQ6XSSclvkBL2iE3Zvdrud6elpLBYL7e3t9PT0cO7cOdra2piYmMDhcKDX64mOjiY7O5vc3FxiY2NJSkoiJSUFnU53y3JjhNqT09PTjI6O0tPTI57YGhoaGBoaYmBgALvdjk6nw2g0UlJSQnZ2NhkZGaSnp6PVaomIiJByCCVuKcJ8EiIRzWYzQ0NDtLe3c/bsWXp7e+np6WF6ehqVSoVer2fJkiWkpKSQkJBAVlYWsbGxGAyGW5pQ7fP5xHy34eFh0d/Y0dHB4OAgHR0dTE9PExISQnx8PPn5+aSmplJcXExqaiparRatViv64aT5tLgJekV3KUK1/sHBQYaHh6mvr6elpYXh4WH6+vrEHl1CRJlarcZgMBAXFyf+n0ajEU064eHhYvRnaGgoMpkMuVwuTgyZTIbH4xG/1+Px4PV68Xg8OJ1OXC6X+HebzYbNZmNiYoLh4WHRRDk5OcnMzAwul4uoqChiY2NJTEykpKSEtLQ0EhMTiY6OliaixJwjjGsht6y2tpbe3l66u7vp7u7G4XDg8XjEeaNWqzEajURHR4sbtoiICJRKJUqlkvDwcEJCQlAqlWLg1KUPmUyG1+vF5/OJCld4OBwO3G43Ho8Hh8PB9PQ0DoeD4eFhJiYmmJqaYnx8HJvNhtVqpb+/n4GBAfR6PQ888ADl5eWkpaWRm5tLZGQkoaGhgb69EkHEvFJ012J6epqOjg7q6uro6uriwoUL1NbWMjY2xsTEBH6/n7CwMNRqNWlpaeh0OvR6vagANRoNWq2WkJAQQkJCiIiIEH1909PTonKbnp4WHyMjI1gsFqamphgdHaW3t1d8rUKhIDIyksTERMrLy0lPTycnJ4fy8nIiIyPRarWBvmUSEtfE6/XS0tJCR0cHbW1tnDlzhra2Nnp7exkeHsbn8yGTyTAYDMTHx2MwGIiOjsZoNIr+QLVaLSo8QQGGhoZit9tF5Wa325mZmRH7v1mtVqxWKwMDA4yMjGA2m/F4PMjlcsLDw8nIyKCgoACj0YjP52Pv3r1ERUXx85//nJycHKnJsMQ1WRCKTjBzCCcs4QTldDqZmpqiq6uL8fFxhoeHGRkZEc2gZrNZ3Dk6HA5Roc3MzOD1egHEppYKhYLw8HDCwsIICwtDr9ej1WpF845gzomPjyc1NRWVSiW+/tITpLC7lZAIVoQIaOExMzOD2+1menqac+fO8Z//+Z+cP39eTHkRToVWq5Xp6WmsViszMzN4PB48Hg8ul0tUbu+fT6GhoYSFhWEwGFCpVKhUKqKiojAYDBgMBlJTU4mLiyMyMlI8PSoUCnw+H9/5zneoq6vDYDDwgx/8gCVLlkhzS+KqLAgPrVwuFxXQpQhmRYPBgNVqZWJiQvTnORwOpqamcDqdOJ1OUbm5XC7a2tq4ePEiFouFnTt3imaYsLAw0UwjmHLCw8PRarVER0ej1WqJiooiJiZGnJASEvMNIQL6/fVT7XY7p06dIiwsjNjYWLZu3SqaI+12OzabDafTyfT0tDifhDnl8/nw+XwolUpxsxcWFiaaOoWCEOHh4ej1etGnbjKZxBOi4FIQTK4VFRX4fD4OHTpEfX09arWajIyMAN01iWBmQSi6axESEoJGo0Gj0dzwe5xOJ7t37+a//uu/aG5u5v/8n/8jFUyWWPQI9TTPnj2L2+0mMzOTBx98MCCBHoL/fOvWrahUKn7/+9/z7rvvolAoSEtLk4K5JK5AOudLSEh8IF6vF6vVyu7du4mNjeWOO+4IuJkwLi6OpUuX8sQTT3Ds2DF+//vf09PTg8vlCqhcEsGHpOgkJCQ+kNHRUdrb27FYLCQkJFBUVBTwk5NCoSA6OprNmzdjMBgYHx9n7969Yn6qhISApOgkJCQ+kL6+Purq6nC5XKSkpFBYWBhokYD3elxu3ryZrKwsXC4XL7/8MiMjI3g8nkCLJhFESIpOQkLiA6mpqWHfvn2sXbuW3NxcjEZjoEUC3vPXhYaG8uSTT/LAAw9QVVXFm2++SVVVVaBFkwgiJEUnISFxTXw+H1NTU/T29tLb20t5eTmxsbFBUxBZMJ+mpKRQUFDA0qVLOX36NKdOncJms+Hz+QItokQQICk6CQmJa+L3+8UeiaOjoyxfvjxoTnOXEhMTQ05ODuvXr6ehoYHTp08zPDwsmTAlAEnRSUhIXIeZmRlef/11+vr6MJlMrF+/nvj4+ECLdVXS09P52te+RkZGBl1dXXzve99jfHw80GJJBAGSopOQkLgqQu7cqVOnCAkJoaysjPDw8KAthKBQKNBoNGzbto2cnByqqqqoq6ujr68v0KJJBBhJ0UlISFwVj8eD3W6nvr4elUpFSUlJUHcCkMvlhIaGsnbtWvLy8ujr6+P8+fN0dnaKhaQlFicLujKKhITEh6enp4eamhr6+vrYuXMnd955Z8CTxG+EpUuX4na7aWho4Fe/+hUDAwMUFRWh0+mCVklL3FqCf9RKSEgEhO7ubqqqqkhNTRWLKwe7ohBabaWlpfHYY48RERFBe3s7b7zxBtPT04EWTyJASIpOQkLiMoRecQMDAzQ0NJCenk58fDx6vT7oFZ1AdHQ0q1evJiEhAavVyqFDh5icnJTKgy1SJEUnISFxBVNTUzQ1NXH69GnuuususrKyAi3STREaGorBYOCJJ54gLy+P1157jVOnTkmBKYsUyUcnISFxGR6Ph5MnT9LT04NSqaSioiJoUwquhXDyLC8vZ2JigpqaGl555RWsVitJSUmEhobOm9OpxEdHOtFJSEhchs/no66uDovFQnR0NCkpKeh0ukCLddPIZDISEhLIzc1l2bJl1NfX09DQwODgoFQxZZEhKToJCYnL8Hg8vP3223g8HjZu3IhWqyUkZP4af4qLi/nbv/1bPB4PVVVV/OY3v8HpdAZaLIk5RFJ0EhISImazmdbWVtrb24mKimLTpk1BnTt3I4SHhxMXF8fDDz9MZGQkf/zjH2lubmZiYiLQoknMEZKik5CQEDGbzbS3t+NyuYiKiiI7O3te5M5dj5CQEFQqFRUVFSQkJDAyMkJNTQ0DAwP4/X4pkXwRMH/tERISErOK3++ns7OTffv2ERMTQ3Z2Nvn5+YEWa1aQy+Vs374dq9XKhQsX+M///E9cLhf5+fnzXpFLfDDSLywhIYHf78ftdtPR0UFlZSWbNm0iNzc30GLNKjKZjBUrVvCVr3yF4eFhjh8/zq5du6QOB4sASdFJSEgAMDw8zODgIKOjoxQVFREfHy/2e5vvCNcRExNDcXExCQkJjI+P8+6772K1WnG73YEWUeIWIik6CQkJfD4fZ86cobW1Fbfbzdq1a0lPTw+0WLOOVqslNTWV+++/H6/Xy0svvURvby82m03y1y1gJEUnISGBz+fjnXfewWKxsHbtWkwmExEREYEW65YQGhrKxz/+cdavX09kZCT/+q//ysmTJwMtlsQtRFJ0EhKLHLfbjc1mo7W1Fb/fT1FRUVD3nfuoyGQyYmNjKSgoYNmyZVy4cIGmpiZ6e3sDLZrELUJSdBISixyHw8HQ0BBNTU0olUrWr19PaGhooMW6ZchkMkJCQlixYgWf+tSn6Orq4syZM5w8eRKv1yuZLxcgkqKTkFjkdHV1sWvXLsLDw8nOzmb16tXzuhLKjRIbG0tZWRmPPPIIg4ODPPvss4yMjDAzMxNo0SRmGUnRSUgsUoTgi7GxMWpqakhNTSUpKQm1Wr0gIi0/iJCQELRaLRs3biQ2NlaMwhwaGgq0aBKzjKToJCQWMV6vl8HBQU6dOkVpaSmZmZnzvuTXzaBUKrnnnnsoKipCoVDwyiuv0NLSgs/nk0yYC4iFb5+QkJC4JmfPnqW2tpaRkRG2bdtGYWFhoEWacyIiIrjzzjuJjo7m61//OmlpaURERLB27dpAiyYxS0gnOgmJRYrf76e+vp6RkRHi4uJISkpCr9cHWqw5RSaTIZfLSUpKori4mNTUVDo7Ozl06BBOpxOv1xtoESVmAUnRSUgsQvx+Pz6fj3PnzjE2NkZubi5xcXFotdpAixYQTCYTBQUFrFq1ir6+Pvbu3YvZbJYqpiwQJEUnIbEIcbvdmM1mKisrcTqdPPDAAws2QfxG0Wq1fOtb36K0tJSxsTF+8pOf0NTUFGixJGYByUcnIbEIMZvNXLhwAYfDgcFgoLS0dEHnzt0Icrkco9HIsmXLmJycpLKykqVLlxIbG0tcXNyiCdBZiEiKTkJiETIxMcHp06eB98x2+fn5iyJ37nrI5XJUKhXLli3D5XLx5ptv0tDQQEpKCnFxcfj9fknZzVMW98iWkFik9PX18ac//YmVK1eyfPlyVCpVoEUKGkpLS4mJieHtt9/m4MGDNDU1sWzZMpRK5YIti7bQkXx0EhKLCL/fz+DgID09PfT09FBSUkJWVtaCacczGygUCiIjI3nooYfQ6/X09PRw4MABxsfHAy2axIdEUnQSEouMvr4++vr6mJycJC8vj9TU1ECLFHSoVCq2bNlCQkIC09PTHDhwgKGhISkKc54imS4lJBYZ+/fvp76+nuzsbIqLi0lOTg60SEGHQqEgISGBBx54AKPRyE9/+lPy8vKIiIgQT8AS8wfpRCchsUjw+Xy4XC5qa2sxm82sXbsWlUolLdpXQTDlFhcXs379elJSUnj33XfZs2eP1KB1HiKd6CQkFglutxuLxUJXVxdhYWEsW7aMsLCwQIsV1CQlJeHxeCgsLKS9vR2fz8fHP/5x9Hr9ok/HmE9IJzoJiUXC2NgY+/btY2xsjJiYGO655x7UanWgxQpqZDIZCQkJfO9730OlUlFdXc0LL7zAyMhIoEWTuAkkRSchsUgYHx/n0KFDpKSkkJubi16vRy6XloDrIZPJCA0NJSkpiQ0bNpCfn89LL71Ec3MzZrM50OJJ3CDSKJeQWAQIJb8uXLhAUlISaWlphIeHS4ruBlAoFOh0OsrKysjLy6OlpYWmpiZ6enokf908QRrlEhILHL/fz+joKB0dHZw7d05MEpe4ObZt28bOnTtJSEjgpZde4ve//32gRZK4QSRFJyGxCKiqquLChQtER0dTVFRERkZGoEWadygUCpKTk/nKV76C0+nk7NmzHDx4EKvVGmjRJD4ASdFJSMxzPB4PDoeD/v5+rFYrbrdbNKcJf7a0tNDX10dKSgqxsbHodLpAijwvkcvl6PV6Vq1aRXR0NDabjePHjzM5OYnH4wm0eBLXQVJ0EhLzHLvdTm9vLy+//DJNTU1XnDC8Xi+nTp2ip6eH7du3o9frpdy5D4lKpaKgoIA77riD5ORknn32Wdra2rDZbIEWTeI6LMo8OofDgdls5oc//CFTU1P4fD7xOa/XS39/P+3t7UxNTfG5z33uCod9WFgYycnJfOITnyA9PX2uxZeQuAyHw0Fvby//8R//wYsvvii2mqmoqCAmJgafz0dvby8qlYrt27ej0+kkRfcRkMlk3HvvvURFRXH69GleffVVBgcHeeyxxwItmsQ1WJSKTpjkdXV1DA4O4nQ6xef8fj9OpxO73Y7H46GysvKK9wth2TMzM3Mms4TEtfB4PExPT9PZ2Ynf70etVmOz2bDb7RiNRuRyOVNTU0RFRREbG7vo2/HMBgkJCeTk5FBUVERzczM6nY4tW7YQFRV12f31er243W46OzsxGAzExMQgl8uljcYcsyhHfHh4OAaDAa/Xi9lsvm7yZ3d39xX/l5SURHJyMuHh4bdSTAmJG8Lj8YjFhv1+PzabjdOnT3Pq1ClkMpk43iMjI8X3vD8kXlp4b46wsDAyMzP567/+a770pS/hdDpZvXo1mzZtQqPRiK9zuVyYzWZ+9rOfsW7dOu66665F38k9ECxKRQfvRVBt3boVuVzO+Pg4Xq/3ht+r0+m4/fbbiYqKuoUSSkjcGB6PB5fLddn/CeNZsFAIyeL33nsvWVlZZGdns3r1atatW4dOp0OpVAZC9HmNwWBgzZo13H777bS0tPCDH/yA7Oxs0tPTCQsL49ixYxw9epR33nmH9vZ2ADIyMigtLZX62s0xi1bRyeVylixZwsWLF28q4VOj0WA0GklKSpLqBEoEBV6v97pRf0IxZ5fLxfj4OBaLhZGREWw2GzabjdzcXEpKSggLC5NOdjdBSEgIOp2OiooKPB4Pu3fvpqamhtHRUQDeeecdzpw5Q11dHQ6Hg6GhIXp7eykuLpYU3RyzqBXdypUrOX369A0rOplMRlxcHOnp6cTFxUmLgkRQ8EGKDrgs4GpoaIihoSGqqqp4/fXXeeihh/jOd75DdHS0tAB/CHbs2EFoaCh//vOf+eMf/4hcLmdycpLKykqcTicymYyQkBAmJiZoaWlh+/btgRZ50bFoFZ1MJiM2NpaMjAyWLFlCU1PTBy4WcrmciooK1q1bN0dSSkh8MILp8kY3bILSk8vlfP7zn2f9+vVERUVJ5cA+JBqNhrS0NDZv3szx48ex2Wx4PB4xWM3v9+PxeOjt7eXcuXM35SaRmB0WtaILCQkhLi6O/Px8Wltb8Xq9H7hYpKWlkZ2dPUdSSkh8MDdyons/BoOBjIwMVq5cSWZmphSJ+SEQol3PnTvH+fPn6e/vx2w2Mz09DVwe8OP3+7FYLPT29uLxePD7/ZJFaA5Z9KM7KSmJiooK9u7de4VD/2pkZ2dTUFAwB5JJSNwYN6vohFJW9913H2vXrpWCqm4CQXn5fD6mp6fp6+vjv/7rvzh//jzNzc3X3SibzWY6OztxuVz4fD7JTDyHLHpFl5mZSWhoKN/73veu+RqZTIZKpaK4uJjU1NTLwrQlJAKN2+1mZmYGuVx+XbOYTCZDLpezevVqtm7dylNPPYVWq51DSec/fr8fr9fLn/70J06ePMkf//hHpqammJmZ+UBrkHACbGpqIicnB5PJNEdSSyx6o3xERARGo5Hk5OTrVoyIiIigtLSUyMhIFAqFZHaQCBq8Xi9er/e6Y1ImkxEWFkZsbCy33347q1evlvrRfQiE3Nvz589z7tw5BgYGsNlsN2QNkslk+P1+enp6mJycnANpJQQW/YlOqVSi1WrJzc1lenoaq9V61Z1ZREQEK1eulMw8EkGHYLqUyWTiYvp+hJ5qWVlZ7Ny5k6ysLGmz9iFwu92MjY3R2NhIR0cHMpnshs3Gwv1ub28nKyvrVoop8T6k7RwQGhrKXXfdRU5OzlUXCblcLiaJS+YGiWBDiLq81ulMoVAQGRnJmjVreO6558jIyCA0NHSOpVwYREREkJOTw7PPPstPf/pTVq9ejVarvaFNg9/vZ2ZmhjNnzjA0NDQH0koISIqO9xaCoqIiYmNjr3AQX5o7p9frpeg0iaDj0mCU9y+4crkchULBHXfcwfbt24mPjyc0NFQ6zX1IhGjtmJgYioqKePzxx7njjjsoKir6wPcK/r2Ojg7MZrPUnXwOkVZt3lN0ubm5xMXFERYWdpkpQi6Xk5ycTE5ODuHh4ZJPQyLouNR0eSnCohwZGck999xDRUXFZXUYJT484eHhpKenk5aWhlKp5MiRI3R2duJwOK6bpuTxeOjp6cFiseD1eqXIyzlCWrX/G7VaTX5+PrfddttlpZD8fj9Lly5l8+bN0i5YIihxu91XDYaQyWTk5OTwi1/8gk2bNpGUlBQA6RY2MpmMBx98kG9+85v84he/IC0tjfDw8OtafqxWKwMDA3R1dUknujlCUnQgOvGTk5MpKyu77DmFQkFqaio5OTkBkk5C4vr4fL6rBkSsXr2a7du3U1JSgkajkawRs4ywbiiVSoxGI8uXL+ev//qv2blzJ7Gxsdc0EQuF5CVFN3dIpstLSEhIoLCwUIxck8vlaDQaEhMTSU5ODrR4EhJXRTBdCoumXC5HpVKxZs0aNmzYQGpqaoAlXPhoNBrUajWPPvoocXFxYp9Lm812Rd9KmUzGxMQE3d3dkqKbI6Qt3iVkZGSwZs0aNBoNISEhREREsG3bNlJTU6U2JhJBixB1KZzqYmJi+Mu//Es+9alPsXXr1gBLt7gwmUzs3LmT1157jccee+yaQSq9vb3U1NRcVmxb4taxKE90fr8fn8+HzWbD6XSKD6/Xy8TEBCkpKaI5KD4+HrPZTFNTE6GhoYSFhaFUKtFoNISHh0vOZImbQoi0s9vtzMzMMD09jdPpxOfzie10hL8rlUoxajIkJASlUinmfYaFhYkpAkIXa5/PR2pqKkVFRTz00EMkJCRI43MOEcyUISEhaLVaHn30UXJzc8nKymLXrl1i9RSfz8fg4CAtLS03VYhbqKxit9txuVzi53k8HjwejxjcIowX4c/w8HAiIiLEPxdjrMGCU3TCQuJyuUSTjtvtFgeC2+0W/99sNmOz2bDb7dhsNnw+H3a7HZVKRWhoqDiA2tvbsVgsKJVKVCoVERERGAwGNBoNoaGhKBQK8c+QkJDL/k9YjBbj4FpsCGNPGDfCuLv0IYy9yclJ7HY7U1NT2O120fQ4PT2N1+vF5/OJG6mQkBDCwsIICwsjIiKC6OhoVCqV+PzY2Bh2ux2FQkFSUhIFBQWUlJSgVCql4sEBQC6XI5fLWbVqFVFRUWg0GmpraxkeHsZqteJ2uzGbzfT39+N2u8XAFeFULqxTwuZFGDszMzNMTk5isVhwOp1MT0/j8/nEEnBer1dcf4RHSEgIGo0GrVaLRqNBp9OhUCiQy+Xi85euVcJ4g4W1Zsn8C8xI7PV6cblcXLx4kcHBQbq7u2lra2NkZIS+vj56enqwWq1YrdbL6gK+v9K48G/B4Sxw6d+VSiURERHExMSQkpKCyWQiJSWFzMxM4uPjSUtLIzMzE6VSuaAGjcTV8fl8zMzM0NnZycDAAC0tLfT09DA8PCz+39TUFGazGZ/PJ46xm+mHKBAaGopSqSQuLk5UqDMzMzz66KOsWLGCkpISUlJS0Gg00tgLIMLGp7q6mpdeeomXX36ZsbExfD4fsbGxHD16lJiYGGQyGfX19fT09DA0NER7ezs9PT2MjY3R39+PxWJhZmbmMlPnzY4boQycwWAgMjKS9PR0kpKSiI2NJTMzk8zMTGJjY0lPT7/sfQuBeavoBGU0ODjI6Ogozc3NdHd3MzY2Rm9vLxMTE+LpTa1Wi7th4RSmVCrR6XTikV6tVotKLSwsjPr6ekZGRli3bp1oSvJ4PDgcDmZmZrBarUxPT4smBMHp7HA4mJ6eRqFQEBERQVxcHEajkfj4eHJyckhKSiIpKQmDwSBFwc1ThLE3MTHByMgIFy9eZGBgQFRok5OTYj5VREQEYWFhqNVqVCoVSqWSsLAw0fStVquJiIgQ66eGhYWJJwLBKiHs2l0uF06nk8nJSZxOJzMzMzidTpqbmxkaGsLv96PX61GpVGg0GmJiYjAYDKSmporNgrOzs4mMjJQKH8whfr8fs9lMc3MzNTU1/N//+38ZGhrC4/HwyCOP4Ha7cTqdjI+PizVLNRrNZWPn0nGj0WgICwsjPDwcmUx2mUVJsBgIJ0Ov14vdbmd6ehqHwyHW5XS73dhsNnE9m56eJiIiArVaTUxMDKmpqcTExJCWlkZeXh4GgwGdThfoW/mhmVej3efziYrE4XBgtVppb29nYGCAhoYGuru7GR8fZ2hoSLRN63Q6DAYD0dHRxMbGkpiYiFarRavVEhUVhVqtRq1Wo9VqkcvlyGQywsPDSU1Npa+vjx07doi7MrfbLX632WxmcnISm83GxMQE/f39TExMMDg4iMViwW6343Q66erqwmAwEBcXx/DwMOnp6WRmZpKcnCyaQXU6HSEhIZLiC2L8fj8Oh0M0GU1NTTEwMCAGFQwMDDA6OkpfX5+48ERGRqLVaomOjhZ3zjqdjsjISCIjI8Vxp9FoRHPSpUpPMEcJwSZOpxOHw8HExARWqxW73c7o6ChhYWFERUUhk8kYGxvDarUyNDREV1cXarWa3t5e+vr6SEpKwmq1kpiYKCpenU4nLpISs49gVnQ6nWi1WtLT08U8O6fTSWVlpbhxCgkJQafTodVqxc1xVFQUcXFx4njR6/Xo9XoiIiJQqVTIZDJx4y4oOsHsKSg8q9WKzWYT16rJyUmmpqZEa8P4+DhjY2Oiog0NDaW3t5eYmBh6e3ux2WzExsYSGxuLVqsVN2ghISHz5tQ3r050TqeTc+fO8e6771JXV8fhw4cZHx8HIDExkZKSEtLS0igpKaGsrIzY2FiMRuOH+jEE09KHWQA8Hg8TExN0dXVx9uxZOjo6aG5u5vTp02L34cLCQkpKSigtLeX+++8nOjoatVp9098lMTf4fD6qq6upqanhzJkz7N+/n/Hxcaanp0lJSSEnJ4eMjAxWrFhBfn4+SUlJxMfHz8lCIPhylEql6GduaWnhwoULdHV1UVtbS01NDePj4zgcDvLz88nOzqaiooJ7771XXEglZp+BgQFaW1vZtWsXtbW1NDY2MjQ0RFhYGCqVipiYGO68804qKipYsWIFRqNRVGBzhbCR7+zspK+vj5qaGmpra+nq6qKurg673Y5OpyMzM5OtW7dSWlrKmjVrMJlM88YyENSKTjhBnThxgrq6OlpbW2lsbEShUBAeHk5ycjKZmZliLUqdTodKpUKr1aLX68Xj/odB2GW930d3I++D9xzLDoeDyclJpqensdlsjI2NiaeA1tZWRkdHmZqaEqvKZ2VlsX79etLT06UuCQHG6/UyMzPDqVOnaG5upq6ujosXL+L1elEqlaSmpopm6KysLLRaLSqVisjISNEseWmFnVuJ4LcRvsvr9WKz2bBarTgcDqamppiYmGB8fJzW1lY6OjoYGxtjZGQEnU5HQkICeXl5bNy4keTkZKmCyodEKNosWJiOHDlCT08P/f39hIaGEhUVhclkorCwEJPJhE6nY2hoiPz8fFJTU8U1a66Vh7DWCRHAU1NTTE1NMT09LUacDw0N0dvbS29vr2haLS8vJzc3l6KiIgoKCoK6UHjQqWOfz4fX6xWP00NDQxw7doympib6+vqw2+2kp6eTnJxMeXk5hYWFJCYmkpiYOKuLys0quEvfB4hRcsJOWdg1DQ0N0d3djVarpbm5mc7OTvr7+5mZmWF8fFysmpCUlITJZEKr1Yo5fPPFTDBfEUK/JyYmMJvNDA0NUVlZSVtbG83NzdjtdjHgqKKiguzsbNLT00lNTQ2o2fn93y3Ut7x07Hm9XiwWC2lpaVRXV9PZ2Ynb7WZwcFBUiiEhIWRlZTExMUF8fLzoPwRp7F0LYczMzMxgsVjo6emho6OD8+fPc+bMGTHKsqioiKysLLKzs1m5ciWxsbFoNBo6OzuJiYkJ6IlaWOsE/5/RaAT+Zy1OTk6mu7ubhoYGZmZmGB0dpaenB7lczsTEBBaLBbfbTVRUlDjuPuz6easIuhOdy+XCarXyyiuvsH//fk6cOMHU1BRFRUUUFRXx8MMPU1RURFxc3GXvC6abei3ef6u9Xi/T09McOHCAo0ePUl1dzcmTJ0lMTCQ7O5svfOELrF69msTERGB+XON8Rgg2+tOf/sS7777Lrl27sFqtJCUlsXTpUh555BEKCgqu6CU2H36X9489IcDl0KFDVFdXc+TIEU6cOIFWqyU1NZWnnnqK5cuXU1BQAMyPawwEgu+2vb2dAwcO8Nxzz4lVUTZv3kx5eTm33XYba9asueLEc2nvwGC8v1dTDW63m56eHs6ePcvLL79MU1MTra2t5OXlsX79em6//XbuvPPOoOuQERSKTjjtHDhwgFOnTlFVVcXQ0BCJiYmkp6ezbds2TCYTkZGRmEwmMQppvnPpTttisWA2m6mrq6Oqqoq2tjaGh4fJz8+noKCARx99lJSUFMmPN8sIZpvKykpqa2t5++23GR4eFs3Jt99+uxg5GxMTc9kpZz4jXLfFYsFqtYpjr76+nvPnzzM0NERSUhK5ubl89rOfJSkpSTKnX4LP52N0dJSTJ0/y+uuvi5HeRUVF5Obmsnz5cpKSktDpdOj1enQ63bwPNhPGjBB1Pjo6ysDAAO3t7ezZs4fR0VGmp6cpLy9n/fr1VFRUkJmZGRTXHVDTpVAhYmxsjL6+Po4cOSKGSsfHx1NUVERpaSlr165dMMrtUoQ2KkajEaPRiNvtxmAwoFAo0Gq1nDhxgv7+fpxOJyaTibKyMtFMO58inoIVIXqyq6uLY8eO0dzcTF9fn5hXtGrVKtauXYvBYCA8PDzQ4s4qgmkpKiqKqKgokpOT0ev1REZGEhoaSmVlJRaLhZqaGg4dOkRBQYFopl3MEcJCdZKuri7a29s5cuQIbW1toolv5cqVFBYWsnz5ctRq9YK6T8KYiYiIICIiApPJRGJiIklJSUxMTNDY2EhbWxsNDQ0olUqcTicul4u4uDj0er0YTRwQ2QNxors0UbahoYF9+/bx0ksvcfHiRcrKyti0aRN/9Vd/hcFgWBC75w+Dw+GgqamJX/3qV5w8eZLz589z1113cdttt/EXf/EXaLXagA6c+cqlw72trY3q6mp+8pOf0NLSgslk4t577+Vzn/scSUlJi7Z3m9frpaGhgT179vDWW29x+vRpVqxYwZo1a/jqV7+KTqdbVEUQLh0zdrud5uZmnnnmGc6dO0dHRwePPvoot912Gzt37hQX9MWIkOj+T//0TzQ2NjI+Ps4jjzzCgw8+SEVFhZiHF4hxM+eKTvi69vZ2jh07xi9/+UtmZmbQarU8/vjjZGVlkZaWRkxMjJhbtBjx+Xw4nU6xMsLBgwc5cOAAFouF+Ph4nnzySQoLC8UqBhI3ht/vZ3x8nN27d/Paa6/R39+PRqPhYx/7GPn5+eTl5WE0Ghd1bpnf78fpdGKxWBgdHWXPnj2cOnWKtrY2kpKSeOihh1izZg25ubmLQtkJa9bBgwc5ffo0L730EhqNhoyMDO6//36KioqIjo4mMjJyUW8+hZzBwcFBampqqKmp4Y033hCLFnz1q18lLS0Ng8Ew57LNqelSqC5y4cIF6urqOHLkCG63m6SkJEpLS8VoJCmn539arSQnJxMZGSkG6TQ3N9PR0cHRo0fF6i+pqakfOo1iseD3+3G73bS2ttLa2sqhQ4eYnJwkKiqKVatWsWrVKrEaxGJHME+Fh4cTHR3N1NQU8F4kcVNTE6dOncLhcCCTyUhISECr1QZY4luHx+PBZrNRX18vulYUCgVlZWUUFxezYsUK4uLiFpxb5cMg1M7MyspCoVCg0Wjo6+uju7ubzs5O9u7dy8qVK8nKyiIlJWVuNwT+OcLn8/mdTqd/ZGTE/5nPfMZfXFzsj4iI8H/zm9/079+/3+/z+fw+n2+uxJmXWCwWf2Vlpf/uu+/2G41Gf1FRkf+HP/yhf3h4WLx/0j28Ep/P53e73f6xsTH/t771Lf+qVav8YWFh/i984Qv+l156SbpvN4DVavU3Nzf777//fn9aWpo/Li7O/y//8i/+ixcv+r1e74K7h8L1TE1N+aurq/233367Py4uzp+VleX/13/9V39PT8+Cut5bgdfr9Y+Ojvp//OMf+zdv3uxXKpX+xx57zP/cc8/5PR7PnI6ZOTFd+v/bXHT69GmeffZZuru7KSws5OGHH6aiooLIyEhUKhUQnGG2wYKQxDw+Ps4f/vAHzp49y6FDh/jYxz7GunXruO+++8QyZhL/g8ViobOzk6effpr+/n70ej1f/OIXKS0tFXMVQRp710OwxgwPD3Po0CGqqqp444032LJlC6tXr+bzn//8ghp7Ho+H0dFRfv7zn1NZWUl3dzePP/44K1asYOnSpWLZvoVyvbcC/39HlU9OTjI4OMjvf/97jhw5wuTkJA899BCPPPIIOTk5c5Jzd8tNl0KU0uHDhzl79ix9fX0sX76c8vJyli5dislkCuqM+mBCKBSdlJRERUUFSqWS4eFhLl68KEbQrVy5ctH2nHo/Qs/BM2fOUF1dTU9PD7m5uSxZsoSlS5cSHx+/aIOdbhahrYuQU6hUKmltbWVwcJDjx4+Tk5NDcXExUVFR896vLtQT3b17N7W1tdhsNjZv3szKlSspKCgQ64pKXB8hqjwqKorw8HDWr1/P1NQUTU1NnDhxgoSEBGw2G0uXLhVff6u4pYrO/99O7f7+fn7+85/T1dVFZGQkTz75JLm5uQFxSs53hMGwatUq0tPTSUxM5Bvf+Abd3d0MDAyQlZVFXFzcguwpdTP4/zs3c2BggFdeeYUDBw4QFRXFww8/zPr168XWKBI3jnC/ioqKSE9PR61W82//9m8cPnwYh8PB3//934tFoi99/XxBMG5ZLBaampr4/ve/j1qtJi8vj29/+9sYjcYFl2YyF8hkMtRqNdu2bcNoNHLq1Cm++c1v4nQ6aW9vp7Cw8JZXf7qlpkuz2czZs2f59re/jcfjYdmyZfzt3/4tycnJhIWFLdqottlCMGVWVlZy8OBBnn/+eR544AG2bt3Kzp07gfm32MwWVquVnp4evvCFLzAzM0NcXBw/+tGPSEhIQKPRLCgzWyAQooKFUlf/9E//xNatW1m7di1PPvkkMP/GnlB68Kc//Sn79u3D4/Hw1FNPsX79epKTkxd1ROVsIZRKO378OD/96U8ZHBzk7rvv5oknniAzM/OW3d9bcqITdtPHjh2jqqqK8fFx7rrrLioqKkhOTiY8PHzemzeCAcGUmZ+fL7YsunjxIlqtluTkZEpLSxddNJgw9mpqajh16hRjY2NiZfiUlBSxK7fER0OICs7MzMTn87FhwwaGh4c5efIky5YtY8mSJfMqGlMohL1r1y4aGhpwu93ce++9lJSUEB8fLym5WUKo/yt0QKirq+PkyZOUlZXhdrvJz8+/Jd97SxSdMGhef/11ampq0Gg0PPTQQxQVFYlBJxKzg0wmIyUlhZCQEFQqFU899RRutxuVSkVOTs6iq2Lh/+9qO4cPH+YPf/gD4eHhbN26lTvvvHPO258sBuLi4lCpVHz+85/ne9/7HlVVVaSkpIil+ubL2HO5XIyMjPDzn/8cj8dDYmIiTzzxBHq9XkrdmWXCwsLIzMxk586dxMbG8o1vfIN9+/bhdDrJycm5JdaWW6Lo+vv7efbZZ6muriYhIYF//dd/JSsrS3L830JiY2PZuHEjX//61zl06BD//u//zvLlyykqKiItLS3Q4s0Z09PT/OhHP+L48eN4PB5+97vfkZaWhl6vD7RoCxaNRsOGDRuYmpri+PHjPPvss6SlpbF27VqxKHSwc+DAAfbu3Utvby9/8zd/I/aInC+Kej5SVFSE0WhkZmaG3/zmN3R2dpKXl0dJScmsVyWadUU3MDDAxYsXqaysJDc3l9LSUlJSUggLC5MGzS1E6NG3cuVKzGYzDQ0N7N27F4/HQ1xc3Jz1Rgsk4+PjdHV1cfz4cXQ6HSUlJaSmpoo+OYlbg1wuJywsjOLiYlwul9h1xOfzkZGRgVKpDNr77/V66ezs5Ny5c9TW1rJlyxZKSkpITEyU/Li3GKFH37p16zhx4gSjo6P84Q9/EBPwZ9PtMmuKzn9Jaa/z589TW1vLfffdx4YNG+YsutLr9eLxeLDb7Vc8J5PJkMvlaLXaKyad/7+rcjudTpxO5xXvFdrGC+3phT5NAnK5HIVCgUKhEEtHBaSem0xGSUkJ4+Pj1NfX8/bbbxMZGcnq1asXdJShMPYGBgbEBevRRx9lx44dcxbuLowJm812RXsTYeypVKorUmmE17pcrquO2/DwcCIiIrDZbHi9XrHJ6rUIDQ0lNDQ0IBsboSRYeXk5Z8+eZXp6mnvvvRej0RiUik7w59bW1nL+/Hk6Ozv527/9WwoLC8W6jLf6+71er1j8+P3I5XJCQkKueroR1iyr1XrZWgT/U9nG7XbjdrtvWJ6QkBDRBTJXaDQaVqxYQXl5OSdOnOC1117jnnvuISoqalYV3axFXfr/u8TSl7/8Zc6cOUN6ejrf+ta3WLJkyZx1zO3o6ODYsWP8zd/8zRXPaTQa4uPj2bVrl9jf7VLZp6am+MEPfsDPfvazK977f/7P/2HLli0cOHCAkydP0tHRQVtbGy6XS+w+kJeXR1FREffccw/Z2dkBDUO22+0MDw9z9913k5iYyPr16/m7v/u7BWs6Fsbez372M55//nlycnL49Kc/zbZt2+YsqVewZDzyyCNXLC5KpZLExER+9rOfsXr16itkt9lsvPHGGzz11FNXfO5TTz3Ft771LT71qU9x8eJF+vv7ryvH7bffzm233cYXv/jFgGxsXC4XY2NjfOYzn2F8fJw777yTJ598kvj4+DmX5YMQoizvvvtutFot2dnZ/OQnP5mzYDm3201zczM/+MEPePPNN694PjY2llWrVvHrX//6it/S7XZjtVrZsmUL7e3tlz2nVCp5+umnOXnyJHv37r1heUpLS1m9ejXf//7353zsjI2NUVlZyRe+8AV27tzJunXreOyxx2bt82dNA01PT3P27Fk6Ozvx+/3s2LGD2NjYOW0LbzAYKC0t5Zvf/CaHDh0SFZKQ6Ll69epr7tTCw8PZsmUL4eHh/PGPf0Sv1xMTE8OKFSvweDz8+c9/Zvfu3cTFxVFcXMzGjRtRKBR4vV7sdjv19fW8++67tLe386lPfYrMzEySkpLm7NovJSwsDKPRyLp16+jt7eXYsWN8+tOfxmg0Lkhl5/V6OXPmDM3NzVitVrZv305WVtacFiLQarVkZGTw9a9/naqqKpqbm7lw4QKFhYXk5uaydetWkpOTr/pepVJJSUkJ3/jGN3jjjTfw+/3ExMSwcuVK1q5di9/vZ3p6GpvNJtadvBbT09PMzMzciku8IYQE4YqKCurq6jh8+DD33XcfWq026LpB9Pb2Ul9fz9DQEMXFxdx+++1z6mKRy+WYTCYeeOABMjIyeOedd8QNdHl5OevWraOsrOya742IiOCv/uqvOH36NCdOnCAxMZHU1FSys7MJDQ0V21DdKCqVKmB1hnU6HampqWzevJnm5ma0Wi3bt29Hp9PNSpT0rGghIdLt+PHjjI+Po9Vq2bhx45wnhBsMBgwGAyUlJcjlco4ePUpbWxt5eXls3rz5mjsEmUxGWFgYGzdupLS0lHPnzpGdnU1hYSGf/OQnef755zl69CgnTpzg8ccfZ82aNaxbt46IiAgx6bGrq4va2lreeecdsahpoBSdYH5Yt24db775JocOHWJgYEDsI7WQEMxPp06doqenB4VCwbp1667oQH+r0Wq1aLVavvrVr/LCCy/wzjvvUF9fT1paGqtXr+Yv//Ivr/o+YewVFRWRn59Pc3MzISEhlJWV8alPfQqNRiOaNFUqFUaj8bqnVIPBEFCFIpfLCQ8PZ8WKFdjtdvbv309vby+xsbFBo+gEI1Zvby+nTp3C4/GQmZnJ6tWr59TEqlAoMJlM3H///axdu5bJyUnMZjNms5nS0lKxo8bVfmvBJ/+5z32OlJQU+vv72bBhAxUVFaxatYoXX3yRkJAQIiIi0Ov11xwvXq8Xt9uN2WwmISHhmpuxW41SqSQ2NpbNmzfz4x//mMbGRgYHB1GpVLOi6GblV/X7/UxMTPD888+TkZHBPffcQ3x8fEBzuDZv3iyaifbv38+ZM2eu2hr+UqanpxkeHub48eOYTCa2bdsmDnydTseDDz7IJz/5Se677z5iYmLQaDQYjUbKy8v59re/zWc/+1m8Xi/PPffcVU0Rc4lCoeD+++9n1apVaDQaXn31VS5cuBBQmW4VMzMzvPDCC/j9fj72sY+RlJQU0E7s5eXlbNu2DZlMRlVVFYcOHfpA39rMzAxjY2OcPn0aj8fDjh07rtiUPProo7z11lu0tbXR3t5+1ccvf/lLPv/5z9/Ky7shtmzZwtatW4mOjubtt9/m2LFjgRbpMvx+P+fOneMPf/gD999/v9g5JVBoNBoeeOABkpOTmZyc5PXXX2dwcFD0xV0Li8VCe3s7J06cYMOGDRQXF4vPpaenc++991JfX3/N8VJVVcUvf/lLwsLCWL9+PVu2bJmLy70qcXFxPPbYY6Snp2M2m3nhhReYnJyclc+elRPdwMAAra2tjIyMkJ2dzdKlS+ekUOf1SElJIT09nZiYGKxWK/39/TQ1NZGVlXVNBdzT00NNTQ2ZmZkkJCSIx/g1a9aQlZWFTCYTOyxfilwuJyEhgfj4eEJDQxkbG8NisYgDNFD3QalUkpqayrJly6iurqa4uBiv17ugosnGx8fp6OhgeHiY4uJiVq9eHfBiu3FxcWRlZWEymXA4HAwNDdHU1CRGgF6N8fFxzpw5Q1xcHCkpKVetp6hQKAgLC5sXSe9KpRKTycTq1atpbW3FZDIFzdjz+Xy0tbXR3d3N5OQka9asITk5OaByhYaGkpOTQ2JiInq9nrGxMTo6OsjIyLhuelBNTQ2jo6Pk5ORgNBrFXFGj0UhKSgpqtRq1Wn3NmIH29naam5vFSNO5CMK5FkL0bmlpKY2NjZw4cYK/+Iu/mJVgplk50Q0ODtLR0SH2RsvKypqNj/3QCD90fHw8SUlJuN1uRkZGaGpqum4UUn9/Pw0NDWRnZxMbGysWR87Pz2fDhg2sX78eo9F41ffqdDoxonNmZuaqUVRziUwmQ6FQEB8fT0lJCW1tbQwMDDA9PR1QuWabiYkJWlpamJmZwWQysWTJkoBH+On1enHsyWQyJiYmaGxsvGpUpcDExATnzp0jKSmJpKQkVCpVwK/joyCXyzEYDCxfvpyhoSG6u7ux2+0feLKdC/x+v7gx9/v9FBYWBrwPYUhICHFxcSQmJmI0GrHb7XR2dtLV1XXN9/j9fhoaGrBYLOTl5V3W+d1kMpGWlkZ2dvZVx5Hf78fn89Ha2kpLSwslJSXExMQQHh4eMIUvRCcvWbIEk8nExYsXsVgss+JznpWZVFNTw5kzZygtLSU3N5fExMSA79oA4uPjuf/++9FqtfT09PCnP/3pugt9fX09Bw8e5O677yYjI+OmvmtmZgaHw8HMzAwpKSlz7iO6Fjk5Odxzzz3YbDZaW1s5d+5cUCw2s0VHRwcHDx4kLy+P/Px8UlNTg2LsaTQa7rvvPhISErBYLLz++usMDw9f8/V9fX288cYbrFmzRqzmPt+JjY0Va652d3dTVVV11fSducbj8bB//36mpqYoKSkhMzMzaAoKlJeXs3nzZgBOnDjB0aNHr/lav9/Pvn37GB0d5b777hPTAuRyOcuXL+eee+7h4x//+FWDsoS4ipMnT1JdXc2jjz56RTR6oNi4cSNLly5lfHyc8+fPXxFV+mGYFdNlf38/AwMDFBUVodPpgmKhAcTIw1/96leMj49z9uxZLBYLer3+MvOl1+ulu7ubwcFBpqenKSsru+kdXkNDAy0tLcB7/sHly5cHxX1QqVSYTCZiY2OZnp6mtbWV1atXB73p60YZHx8XA45iY2OD4p4DREREsG7dOvbv309HRwdnzpxhZGQEp9N5mRnJ7/fT19dHb28vk5OTorK+Gj09PRw6dIhXX32VqakppqenkcvlREVFYTKZWLVqFbm5ude0Osw1gvlS8H01NzdTXl4eYKneM122tLQQFhZGQUFBUNWxzM/PZ3JyErlcTmtrK0ajkenp6SvM1TabjYGBAcbHx4mPjxdbJwE35DZyOBwcO3aM6elpTCYTBQUFQRMsJIzn2NhYenp6SElJobCw8CN95kdSdELC4/j4OGazmYyMjKCqZalWq8nJycFgMDA6OkpPTw8jIyNERUURHR0tvs7n89HR0YHNZkOlUpGYmHjDwQxConB9fT1dXV1ERUWxbNkysrOzb9Vl3RRKpRK1Wo3JZMLtdtPX1/eBQTnzAWHsTU1NMTg4yJYtWwIWGn01lEolOTk5xMTEEBISQk9PD0NDQ1gslitO+z09PYyOjhIREUFCQsI1o5UnJiZobW2lt7eXqakp7HY7fr8flUqFwWDA4/Egl8vx+/0YjcaAL94hISGo1WpiYmKwWCx0d3ffVALzrcDn8+F2uxkcHCQzM5O0tLSA36dLiY+PJz09HY1Gw8TEBH19fYyOjhIXF3eFomtra0MmkxEZGUliYuINb179fj8zMzOcPXsWgKSkJEwmU1DcByHZXa/XYzKZGBkZYXx8/CN/7kcyXfp8PiwWiziBi4uLg8YEAO/lk8XGxrJs2TLS09OZmZnh8OHDXLx48bLXud1udu/ejVwuZ+vWrTdVVcLj8TA+Ps4LL7xAdXU1O3fuZPv27RQVFd2KS/pQKBQKioqKRJv+QjFdTk1NMTIywtDQEAUFBQGNmns/Quh4UVERS5YsweVycfr0aU6dOnXFaw8fPszAwAB33nknOp3umr65mZkZfD4f3/rWt3jhhRc4ePAgv//978XO8t/85jf53ve+x/PPP3+rL++myMnJQa/XU1dXF9AcP3jvHprNZvr6+ggPD6ewsDCorBt6vZ7k5GQqKirQaDSMjo6yd+9eJiYmLnvdwMAAf/7zn1m+fDmlpaU3na9stVp55ZVXSEhI4I477pjNS5gV9Ho9JSUldHV10dPT85E/7yMpOq/Xy+joKA6Hg5CQEBITE4OqMaFwhK+oqGDJkiX4fD7effddmpqaxNd4vV6mp6c5ceKE2AX3Rk0Z09PTNDQ08N3vfld875NPPhl0HYjlcjnx8fHIZDLGxsYWzIlubGwMq9WKTCYjPj4+oBFj70cYe8XFxaxcuRKAc+fOUV1dLb7G5/OJO2uz2cyWLVuu2mEhLCyM73znOzz99NM8+eST5OXlERMTg1qtJikpifvvv5+//Mu/JCcnh+bmZvbv309LS8t1g1/mEpPJhEqlYmRk5IpyVXPN9PQ0Y2NjeL1etFqtOC+CBZlMhlarZcuWLRiNRiwWCwcOHMBisQDvjXuXy8XQ0BCVlZWUlpayZMmSm4py7+7upra2lomJCbKzs4PCnPx+BOvG5OTkTSW9X4uPZLr0+XxMTU3hdrtRKBRERkbOaTWKGyU3N5fW1lYUCgVtbW309/fjcDgIDw8XB/74+DgajeaGmv8JEUvt7e3U1tZSV1fHsmXLWL58OcXFxUEXLSeTyUQlYLVaF4Sig/fMN8IJIVjbqaSlpZGTk4NCoaCvr4/Ozk6mp6cJCwvD7XaLY0+tVpObm3vV+RMSEiIqy/cTGhqKRqMRW59UV1fT2dlJR0cHUVFRAc0nFNBqtSiVSqampgJuTXC5XOIcCA8Pv24ydaCIiIiguLiYyMhI+vr6aGxsxGw2MzMzg1KpxGKxMDY2xsTEBKmpqTddXq2/v5/W1lY0Gg1xcXEkJCTcoiv58ISGhhIZGYnD4ZiVAKaPbLqcnJzE7XYjl8vR6/VzWvLrRikvL6ewsBC1Wk1HRwctLS10dnaKQSgnTpwQw3HT0tI+UFEJ3ZWfffZZfvWrX5Gens4Xv/hFHnvssaBTcgKCopuN3VEwINQndTgcoiIPJmuCQEFBAeXl5Wi1WjGXs7Ozk5mZGcbHxzly5AhqtZqUlBQyMjI+9EZRpVKxceNGTCYTNpuN48ePYzabZ/lqPhwajYbQ0FAmJycDruhmZmaYnJwUFV0wBc8JqNVq1q9fL0ZBNjY20tbWxuDgIABnz56lo6ODpKQkMjIybjpwrrq6msOHD7Nt2zbS0tKCsrNJaGgoOp2O6enpWUmJ+kirsuDU9Hq9YimjYFzoQ0NDSUpKYuPGjYSHh9Pd3c2+ffuYmZmhvb2dw4cPs3HjRjIyMj7wB/d6vfT29vLd736X8fFxiouL+frXv35ZW49gGzSCgxcIuI9kNnG5XKIpTKlUBpWvRUCo/bhp0yaioqKYmJhgz549mM1m0f9SUlJCWVnZRxo7CoVCrPju9XqxWCx4PJ5ZvpoPR1hYGAqFAqfTGXBF5/V6mZmZwe/3o1AoAlq96VrIZDJCQ0MpLS1l2bJlAFRVVXHmzBngvbSDgYEBtm/fjlqtvuEx4/V66evro6GhgY6ODu65556gSQV7P0Itz5vtwHDNz5sNgYQbFWj7+9UQkhCjoqIoKSlBqVQyOjpKTU0NVquVoaEhOjo6bjiYQRgoFy5cIDExkbKyMgoKCkTfit/v5/z58zQ0NATFDlZAkCMYNyIflkvHns/nC0qTrFwuR61WU1JSglarxWazcf78eSYmJhgfH6e5uZm0tLRrphQsBITfJhiqogjrAfyPCyLYEIo9ZGZmitHbLS0ttLS04HA46OjowG63U1paelNWDI/HQ2trKxaLhZCQELKzs4PKr/1+fD7frB0cPtKqJ/R3Cw0NxefzYbPZgmYX+X4SEhK4/fbbiYiIoK+vj0OHDtHd3U1nZyft7e2sWbPmuouNUHPuz3/+My+99BJut5uPf/zjfPKTn7wseMXv9/PNb36TH/3oRzQ1NQW8Qoogk9VqBQiaXJnZQK1Wi345u90eFPf6auh0Ou64447LgguEElQXL16kuLiYJUuWXPW9wri7Xs3DS9N8XC6X6C8PFjeC3W7H4/FctRfkXKNUKtFoNMhkMlwu11X7BwYLS5cuFX2z1dXVnDp1iv7+fpqbm5mZmWHjxo03nM7l9/txOBzs2rULl8tFYWEhaWlpQeHDvRput5upqalZK0T/kRWdTqcjNDQUr9eL2WwOeJ7MtdDr9RQUFJCRkYFGo2FkZIQf/OAHNDc3s2bNGgwGw3XNGGazmeeee46qqioUCgU//vGPyc/PD5rF5Hr4/X4xaisYfRIfBiE6LTw8XLy+YKi6cTXCw8MpKCggKyuLmJgYzGYz//Ef/8GePXtYv349JpPpmpO5vb2dP/7xj/zFX/wFb7zxxjW/w263c+DAAYaHh9FoNNx2221ERUXdoiu6OaxWKy6XC71eHxSKTpDD4XDMWtHgW0Fqaip5eXmkp6fjdrs5f/48//t//2/i4uJEC8GN3k+Xy4XZbObtt98mJiaG7du3B/U64Ha7sVgsqFSqWVF0H2mVlsvlREZGEhYWht/vZ3x8PKhymS5FiE7LyspiYmKCsbExamtrKSgoYNmyZSiVymsOGqHA6qFDh2hra0Or1dLU1ERHR8dVu5UPDw8HVT6h8Nv4/f6gSqr+qOh0OtFkPDExQXx8/GWFAIIFhUKBRqMhNTWVpKQkBgYGaGxsJC0tjTVr1qDRaK7pXxQ6alRVVREXF0d2djYpKSmi30soGt3Y2EhHRwcajYaMjAzS09ODpiWTEDEYFRUVcD9qWFgYer1e9BmOj4+Tnp4eUJmuRXh4OFFRUeTm5mKxWDCbzVRXV7Nx40bS0tJuapM9MTFBV1cXFosFk8l0zfY/wYLQwFej0czKqfMjKbqQkBDi4+PRarX4/X46OjpITU0Nmp3k+5HJZKxevZrJyUkaGxvp7Oxk5cqVrF+//rqD5uLFixw7doxXXnlFNHMcPnz4ut9lMplmVfYPi+CHEIrDJicnB3xXPRvIZDJiY2NFE113d3dA+2ndCKWlpZjNZk6fPk1fXx8JCQls2rTpuuZkwe/b3d3NgQMHcDqdfPaznxUL8A4MDPDmm29SWVlJR0cH27ZtY8OGDeTk5AR8IRPmSl9fH1ar9aqdP+YatVpNXFwcYWFhTE1N0d3dzdKlSwOugK+FXq9n06ZNNDc309nZSWtrK3/zN39zWTue6yH8Bq2trRw/fhylUkl2djalpaW3UOqPht/vx2az0dHRQUxMzKyUtPvIo06IaIyPj6e2tlaMEgpG5HI5mzdvpr+/n7feekvcLZWXl193Al64cIETJ04ErS3/g/B4PNTX11NQUBAU1f1ni9DQUEwmE5mZmVy8ePGmC3HPNRUVFbhcLv7rv/6LyMhI0tPTqaiouK6fJSMjA4PBgFwuF/16X/rSl7DZbDidTtGEGx0dzb/8y7+wfv16MjMz5/Cqro/f76elpQWXy8WaNWsCnusoNCzNycnB6/Vy4cIFduzYEZT5v/Be3cd77rmHP/zhDwwNDaHX61m6dCk5OTk39Tk1NTW888477NixQ2wMHYwIa+zk5CQXLlzgscceIyUl5SN/7kdSdEJEjMlkwmg00tLScplzN9A7yqsRExNDeXk5n/jEJ9DpdCxfvvwDj8YZGRmsWbPmpnYWRUVFGI3GgA+o6elpRkZGRHt3SkpKUP4uN4sw9oSSSZ2dnYyPj89qpNZsYzAYyMvL45Of/CQajYaioiIxMOJaREREoFAoqKioIDY2luTkZAYHB8Vk+ZCQEIxGIzExMaxYsYKsrKygMd+6XC4mJiYwm81oNBrS09MDrlCEqMvU1FSxaanX68Xv9wflmAkNDSUuLo67776b4uJiNBrNh6pAlZGRwfr16ykrKyMhISEor1VgYmKC0dFRLBYL8fHxs9JCaVbsCEIPrTfeeAOz2YzX6w34An81hMTiu+++m7vvvvuG37d9+3a2b99+CyW7dYyNjdHU1ITNZsNgMJCbm7tgTnTwXoeK3NxcXn31VQYGBvD5fEE59uC9iNdly5bdVC1KuVxOeHg4S5cunXfte2w2G42NjVgsFoxGIwUFBUGRtyaXy8nLy+PEiRNcuHABt9sdtIouJCSEyMhIvv3tb3+o9wvXdLNrXiDp7Oyku7ub6elpsQn2R2VWVrwVK1awceNGhoeHOX/+PHV1dbPxsRKzQHNzM2+++SbZ2dnk5+ffUFL8fELot2exWGhsbKSqqiooc6MWI0NDQ/zhD38gJiaGgoICsrOzg0LRhYSEcM8995CSksLAwAAnT56kv78/0GJJ/DcHDhygoaGB4uJicnNzZ6W356woOoPBQEJCArGxsXR1dVFfXz8bHyvxERAaK/b19XHx4kUKCgpISEgQOxAvFDQajTj2JiYmqK6uDsrCBYsNwWReU1NDamoqmZmZQTP25HI5cXFxxMfHYzAYOHPmjFheSyJweDwebDYbTU1NmM1mSktL0Wg0sxLANCuKTqvVEhsbS35+Pu3t7Zw+fTpoK1UsFoSUgo6ODhobG1m5cuWsOHWDDZVKRUxMDLm5uUxOTnL06FHcbrd0qgswFouF3t5eamtryc/PJy8vL9AiichkMqKjo0lJSSEtLY1jx46JtW+lNStwuN1uRkdHaWhowGq1ctttt81af9NZc9YYjUa+/OUv43Q6qayspLKyUkxSlph7PB4P//mf/8nZs2eJi4tjx44dQbXYzCZKpZInn3ySuLg4cewNDAwEWqxFzSuvvMJbb72F0Whk27Zt1+y+EEgqKir4/Oc/z9mzZ6msrOT06dOSogsgPT09/OQnP2FmZoa8vDx27tyJVqudlc+eNUUXFhZGfn4+6enphIeHs2fPHkZHRyUzUgCw2+309/eLRWDXrVtHZGRkUPhHbgUKhYKcnByysrIwmUzs37+fjo4OPB6PtHDNMTMzM/T393Pu3DlGR0fFjgrB2FnCaDSSl5dHamoqAwMDHDx4EJfLJVkDAsDo6Cjt7e2cOnWK/Px8ysrK0Gg0sxY4N2uKTqlUkp6eTlFRESaTibfeeove3t5ZabEgcWMI9RDNZjNNTU3U19ejVqvZtm0b4eHhCyra8lKEcPH8/Hxyc3N55513aGpqCprGo4sFoZ5iU1MTDQ0N2O127rrrLgwGQ1BGwhoMBjIyMigtLWVsbIz9+/eLbcck5gZhzert7aWxsZH6+nqxt2dISMis+XRnfeX7+Mc/zuOPP87w8DC//vWveemll2b7KySug8Ph4MiRI3zjG98gLy+PLVu2sH379oDnL80Fmzdv5n/9r/+FxWJh165d/Pu//7tkUZhDnE4njY2N/N3f/R1arZaNGzeyY8eOoK6Qr1KpePrppykuLqazs5Mf/ehH1NTUBFqsRYPP58Nut/Nv//ZvvPzyy6xdu5Y777xz1ruez7qiMxgMZGVlsWPHDnp7ezl+/Di1tbXSye4WI5T62r17NydOnMBqtXLfffeJdTwXA1qtluTkZO666y68Xi9Hjx6lrq6OiYmJQIu2oBHG3rFjx3jnnXcwm81s3LiRTZs2BU2k5bWQyWTExcWxYsUK1q1bJ/rqmpqaJLP3LUYImHv11Vfp6OhArVbz6KOPEhsbO+ul4mZd0alUKpKSkrj33nux2+1cuHCBqqoqLBaLZBK4hQjVvvfs2cOFCxfQaDRs27aNgoKCoK0UMtuEhYURHR3N3XffjVqtpqGhgVOnTjE4OIjL5ZIWrluEz+djamqKo0ePUllZSUREBLfddhsVFRVBP/aEVmNLly5l06ZNtLS0cO7cOc6fPy82lZa4NUxPT9PT08Prr7+O1WolMTGRHTt2EBkZOetj5pZUWDUYDNx99910d3dz7NgxvvrVrwKwatUqioqKbsVXLnrq6ur4zW9+w969e1m7di3/8A//QFpaWsBrC841SqWS7du343Q60el0fPOb3+Spp57innvuYcWKFYEWb0EyODjIj3/8Y/bu3YtWq+WnP/0pS5cuDWqT5fspKCggPj6euro6KisrOXHiBCaTicLCwqDtyDLfefHFFzl8+DCHDx/mn//5n1m3bt2sFHC+GrdE0clkMkJCQti4cSNarZaBgQH27NlDf38/YWFhpKamLroF+FYgOHIPHjzIu+++y7Fjx7jzzjtZs2YN+fn5hIaGBvVu+lYgjL2lS5cSHh5Oa2ur2NFbr9eTmJg4ayHLixnhdHz69Gmqq6s5dOgQS5cupbi4mIKCAtRq9bwae3K5HI1Gw0MPPQS81+j05z//OR/72MdYvnw5qamp8+p6ghW/38/U1BQHDx5k3759DA4O8ulPf5qVK1fe0nt8S3tmFBYWolQqqa2tZd++fdhsNvLz89HpdBgMBknZfUiERWZmZkZMkj537hxjY2Ns3ryZsrIy4uPjAyxlYMnIyCAyMpKVK1fy7rvv0tPTw9q1a1EoFISEhBAeHi4tXB8SoaP5xMQEVVVVvPvuu4yMjPCpT32KdevWER8fPy/vrVKpZNWqVfT29mK1Wtm9ezdpaWmoVCqMRiPh4eEBbzM0XxHWrKmpKXp6enjnnXdobW1Fo9Fw7733kpube2vbu/lvIT6fz+/xePzT09P+v//7v/evW7fOr1ar/T/5yU/8p06dupVfvaDx+Xx+l8vlr6qq8n/iE5/wm0wm/7p16/y/+93v/JOTk36fzxdoEQOOz+fz+3w+v8Ph8D/77LP+O++8069Wq/1f+9rX/O+88450jz4Cbrfb39PT4//0pz/tz8rK8mdlZfl/85vf+Ht7e/1erzfQ4n1ohDHjcrn8XV1d/kceecSflZXlz83N9b/88sv+gYGBQIs4b/H5fP6ZmRn/s88+69+xY4c/PDzc/9WvftW/e/duv9frveXz8ZZuT4SWGGFhYXzsYx8jOzsbrVbLrl27uHjxIt3d3dxxxx2zmhi40HG5XExNTfHaa69x7tw5qqur+djHPkZZWRlr164lIiJiXu6mZxuhYalSqWTr1q0kJSUhl8s5e/Ys7e3tTExMsG7dOmJjY4MyxysY8Xq9mM1mDh48yOnTpzlz5gxr1qyhqKiI2267jaioqHk9j4V5o1AoMBqNPPnkk+zatYuGhgZ++tOfik1aN2zYgEKhkObZDWKz2RgeHuaFF17g5MmTWCwWvvKVr7Bt2zays7PnJGDplp/DhQsoLS1FrVYzNjbGCy+8wPT0NAqFgoyMDJKSkoiKilqUPqWbwW63Y7FYaG5u5tChQ3R1daFUKtmwYQPFxcWkpaUFWsSgQphA2dnZREdH09rayltvvUVjYyOHDh0iOjoaj8dDXFwcISEh83qRvtU4nU5sNhv19fVUVlZy5swZQkJCWL58ObfddhtpaWkLZu7K5XJUKhVr1qzBbDYjk8l46aWXOHHiBNPT06SmphIbG0tERMSiyE/9sPh8Pmw2G93d3bS0tPDOO+/gdDqJjY3l7rvvJj8/H4PBMCeyyPz+uYm5Fr7G7/fz+uuvc+DAAV588UVyc3O58847+cxnPkNKSopkA78Ox44do7Kykp/85CdER0dTUVHB1772NbKzswkLC1swC81sc+nYO3ToEMePH+eZZ54hPT2dZcuW8fTTT3+oZpaLidraWk6fPs3TTz+NWq0mIyODZ555htTUVPR6/YIbe5cuixMTE7zxxhv8/Oc/p7u7m8zMTJ5++mlKS0tnpVfaQsXhcPD222/z29/+lnfffZeYmBi+9KUvsWnTJrKysoC5a849Z4pOwO/3Mzg4SFdXFzU1Nbzyyiv4fD4MBgMPPPAAJSUlLFmyZFbLv8xnLBYLfX19vPHGG5w4cYLJyUkMBgMPPvggBQUF5OXloVarJfPbDTI6OsrQ0BDvvvsue/bsYWRkhOjoaLZv305RURGrV6+Wxt5/Y7PZGB8f5+WXX+b8+fN0dXVhNBrZtGmT2Ah2MZxqXC4Xg4ODnD17lvr6enbt2kV0dDRpaWls2bKFTZs2YTAYpE06753ixsbGqKqqoqqqigMHDqBWq4mLi+PjH/84eXl5xMbGolKp5nSOzfkvI5PJSEhIQKfTYTKZqK+vp7m5mebmZiorK3E6nfj9fpKSklCr1URERIjvWyx4vV5cLpfYZqelpYVjx44xMjJCZGQkq1evZsOGDSQmJi74RWa2iYmJQafTodFoGBgY4Pz58zQ2NhIZGYnVahX722k0GjQaDbC4xp7P58Pj8TA6OsrAwACdnZ3i2PN6vVRUVLBu3TqKioqCvurJbKFUKsWUKKPRSHNzM42NjUxNTREaGorBYCA5ORmTyYRer190/jv/f0fh2mw2LBYLDQ0NvPvuu5w5c4bJyUny8vIoLy9nw4YNhIWFBWRTPucnOgHhaz0eDzU1Nezbt49nn30WeG8x+pu/+RtWrlxJQUEBcrl8UQ2cqakpBgYG+PWvf81bb71FX18fiYmJfPGLX6SiooKSkhLxtYvpvswWwtjzer309vby2muv8fzzzzM6OorBYOCJJ56gvLycNWvWLLqxNz09jdls5he/+AVHjx7lzJkzJCcn89BDD3HHHXeI1U5g8Y09/3/nrXo8Hl577TUqKyt58cUXiY6Opri4mIcffpg777wTvV6/qPy9/v8u5XXy5EkOHjzIr3/9a9RqNSkpKfzDP/wDhYWFl6U7BWLcBEzRwf8MHMFEUldXx/nz5zl37hw9PT3ExcWRmprKjh07KCgoEE8wC3GCWa1WxsfH2b9/P6dPnxYjAwsKCsjOzub2228X/SFSwvPs4Pf7cTqdjIyM0NjYSHNzM4cPH6avrw+VSkVGRgZ33303OTk55OXlLdix53A4mJycZN++fdTV1VFbW8vY2BjJycnk5ORw9913k5SUJJ6GF+I9uFGENWtkZITR0VGam5vZs2cPvb29DA8Pk5+fT0FBAatWraKiogKVSrUgTZp+v5+JiQlaW1s5d+4ce/fuZWJigpmZGcrLy1m2bBlF/7+9946O+6wS/j/TZ6RpaqPeR11ykW3J3bHjxMSYFELCu2GBhJrsWcrCu/BjK7zALrt5lxBgDwd2WVqWLIQQkjgkTty75S5ZtiSr9zrS9D7z+yPv94uT2Imd2J6R/HzOmRPFmhnd+c79Pve597mloYGKigpSU1MTXjOd0G9Ayoozm82YTCZMJpN83uRyuZibm8Pj8WCxWJienqakpIS8vDysVqsc1pyPN510s/j9frxeLxMTE4yPjzMyMsLBgwfp7+/H4/FQXFzMihUraGhooLm5+ZYLidxoFAoFBoOBoqIiOZTu9/vZt28fc3NzckhzfHyc6elp8vLysFgsmM3mm37GcL2QdC8UCuHxeJicnGRmZkbWvcHBQSYnJykqKmLx4sWsWLGClStXotVqbykv5UpIa1ZOTg7p6elkZ2czOzuLyWTC5/PR399PIBAgGAwSiUTIysoiLS2N7OxsdDrdvG2wLumN0+nE4/HgcDjo7e3l4sWLtLa2Mjw8jNFopLS0lPXr17NkyRIqKiqSZs1KqEd3JaLRKAMDA+zcuZPdu3fzwgsvoFarSUtL495772Xjxo3U19dTXl5+2dcnw4W9lMtd4kgkQldXF+3t7fzP//wPZ8+eZWhoiPT0dLZu3cratWv58Ic/jE6nW5A7wmQl/v9mY50+fZrf//73bN++nUAgQGpqKvfddx/Nzc2sWrVKvonfzHzRvbGxMc6cOcNvf/tb2tvbaWtrIz09naamJu68807+/M//HJPJJM6ArxKPx8Po6Cg//vGPOXHiBEePHiUlJYW6ujpWrVrFhz/8YYqKisjKyrrs65Ndb6SQ7cGDBzl9+jR79uxh7969KBQK0tLS+PSnP83atWtpbm5OSgckKQ1dPB4nGAzKXl1/fz9tbW10dnZy8uRJIpEIGo2GsrIyFi1aRGlpKUuXLqWwsJDU1NSk23mGw2ECgQDnzp2jp6eHrq4uWlpamJmZwev1kpeXR3V1NeXl5axatYrMzEwsFotcgJtsSrOQkbwdn8+Hw+FgYGCAnp4ezp49y4kTJwgEAgCUl5dTUVFBRUUFzc3N5OTkkJaWlnTfVzQaJRAI0NnZyeDgIGfPnpWnfzscDnJzcykqKqK2tpbVq1eTmZlJWloamZmZKJXKpLuXkpVoNEo4HGZychKHw8Ho6Cg/+clPGBkZYW5uDr1eT1ZWFrm5uaxatYrKykpKSkooKytLGq/nUgKBALOzs1y8eJETJ07Q399Pe3s7ExMTclLOypUrqaiooKqqiry8PEwmE0ajMSknViSlq6BQKNDr9ej1ejIzM7HZbJhMJrKysojH44yMjOByuRgfHwdgZGSEiYkJCgsLsVgscnjJYDCQkpJCamoqGo3mhoUNLk2sCQQCeL1eucDW6XTidrtxOp10dHQwMTHBxMQELpeLlJQUsrKyWLJkCfX19VRUVLB48WJRvJxAFAoFOp0OnU6H1WolKysLm82G2WwmHo8zOjoqn89I2Ymzs7Pk5OSQkZFBWloaRqMRg8GAyWTCYDCg1WpvaIZi/P/Ng/P5fPj9fgKBAG63G5fLhc/nY2Zmhp6eHiYnJxkaGsLhcKBUKuXwZHl5OYsWLWLx4sXo9XpRqvIuUKlUqFQqOQyuVqsJh8Py0YxeryccDjM6OkpLSwsjIyPk5uZSWloqh8KtVispKSno9Xp5zbpR34UUigwGg4RCIbxeLx6PRz6vdTgccnhyYGAAh8OB1+slOzub7Oxs7Ha73CiguLg46UtyktKjuxLSl9PV1UVPTw+7du3iyJEjDAwMMD4+TmpqKhkZGdTX17N48WLy8/MpLy/HbrdjtVrfUoX/Xr6YN182Kb12dHSU7u5uhoeH6e7u5uTJkwwPDzM0NEQ8Hpdl2rJlC0uWLJGTbIRhS24k3RsZGaG7u5tXXnmFs2fPcv78eXkqh8lkYtmyZVRWVspeUlFRERkZGW8JWb3XReFS/YvFYgQCAQYHBxkcHGRsbIy2tjba29sZGhqiu7ubWCyG1WqlpqaGTZs2UVdXR1NTkyhRuY5I38ng4CDHjx/nL//yL6moqOD9738/TU1NcmRgx44dTE1N4Xa7MZlM2O12SkpKaGxspLS0lNzcXOx2O+np6W9pYnA916xIJML4+DhTU1P09PS8wevv7u7G7XYTj8dpaGigsrKSlStXsnnzZnJzc2/YOJ0bxbwzdPB6Aad0mO73+3G73fT19XHx4kXGx8cZHByUEzr8fj9arRa9Xo/JZCI/Px+j0Sh7iKmpqbLXp1arUalU8q5WoVDg9/uJxWJEo1F5t+z3+5mZmcHlcuH1epmZmWFsbAyv1ysfQuv1ennaenZ2Nvn5+TQ0NJCeno7VapV3/dIZXDLvhgRv9NqDwSAej4dAIIDP56O7u5vBwUFGRkbo6elhdHSU2dlZvF6vHEmwWCxkZ2djNpuxWCxkZGSQkpIiJ2Cp1WrUarVcZ6RWq/H5fG/QvWAwSCAQYGpqCo/Hg9frZWpqiqmpKVwuF36/n2g0KvdqLCoqIjs7m5KSEqqrq8nMzCQzMxOj0YhOp5OLvYXuXR/i8Tjt7e3s2LGDH//4x9TX13PnnXdy//33YzAYCIVCcqRHSkBrb29nZGSEyclJent75e9Qq9XKSXo5OTlYLBaMRiNpaWlYLJY3fH9qtRqNRoNGoyESiRAKheRaXCkM73K5cLvdzM3NMTc3h8vlYnh4mGAwSDgcJhqNkpaWhtVqpbS0lNLSUnJycqisrJQLvA0GA0ajUdbV+cS8kla6IaXQkpRmHwwGSU9PJysri6mpKQYHBykuLsbpdDI7O4vb7SYSiRCLxWRj5HK5mJmZkRcVydhIjails5ZIJAL86TBWKqiVDJr0s8FgIDU1Fb1ej9lsxmw2k5GRQVlZGTabjdzcXMrLy+XnCOYXku5JC4pUTB6NRjGbzeTl5TE5OUleXh5jY2M4HA5mZmbweDzyQhIIBGTPf3p6Wl6gVCqVrG9v1j0pLOn3++V/DwQCsu4FAgG0Wi3p6enyQmQ0GsnOzqawsJCsrCyKi4vlkFpqamoiL+OCJRwO4/F42Lt3L2fPniUej7Nu3TqWLFly2QQUm81GQUEBaWlpjI6OMjU1RWFhIXNzc3i9XtxuN7FYDIVCgcvlIhAIyBtqSWcupzexWIxYLCbrjbRRCoVCshEMhUKEw2E5pKrT6TCbzWRmZpKenk5JSQlFRUXyZsloNM77cPa88uiulVAohNvt5uLFi0xMTDAyMsLg4CBOp1M+43O73Xg8HnlBikQi8s/xeByz2Swbw5SUFPkhpQ1LClJcXExWVhZFRUWUlZXdEq2RBFcmGo0yNzfH4OAgExMT9PX1MTo6ytzcHLOzs3LoSlrYJN3z+/2yEZOGl0pnKRkZGdhsNnJycuTNVHZ2Nrm5udhsNsrLyykoKMBisQhP7SYhLZ9Op5O+vj4efvhhIpEI9fX1fP/73ycrK+uajiWks1UpSjA1NcXIyAgOh0OutXU4HPj9fvx+v2y0JM9MigpI/9Xr9RiNRjlvQVq3rFar3FDfZrNRWlp6Q88EE82CNnTSrkbaUUejUdkrk3Y6l+6ApAVl165dPP300/T19bFnz563eHsKhULeTUkPKewp7dKTMfNIcPOQdC8Sich692bdk1onSboHr5+3SSgUCkZGRjh//jxf/vKX+fjHP85f/MVfYLVaZb2TdE6pVMphLGlhFfp345G6guzbt4/vfOc7qNVqbrvtNh577DHy8vKuOaNS0g9p4yPp0JvXLElnLn1IXLr2XOrtSfoi/XypZyhtyheqzsyr0OW1Ihmka9mlBAIBbDYbBoNBzqKar0WegsTxbnTvcmi1Wvx+PwqFQg6ZZmdni+SlJEAqKdi9ezdHjx5lbm6O+++/n9WrV5Obm/uuygYu3TgLrh/iagoESYzBYJBr2qRSATEaJvHE43HC4TAOh4Nf/epX9PX1YbVa+chHPkJZWZk4tkgyxLZQIEhipGkKUlu8sbGxy3Y7EdxcQqEQZ86c4TOf+QxdXV3U19fz05/+FLvdLk9cESQPwqMTCJIYlUqFVqvFaDQSjUaZnZ0Vhi6BSOdhhw4d4tixY/T09LB+/Xqam5vlYw4RVk4+hKETCJIYKYHAYrEQi8VwOBzC0CWISzvQvPzyyxw/fhyv18t9993HkiVLsFqtiRZRcAWEoRMIkhylUkl+fj7weru7SzMzBTeXgYEBnnjiCV555RVycnL4j//4D5qbmzGbzYkWTfA2CEMnECQ5Uof4YDDI7OxsosW5ZTlz5gwnT57k0KFDLFmyhMWLF1NbW0tKSooIVyY54tsRCJIcydABInSZAKRw5bFjx9i7dy99fX2sXr2aLVu2UFhYKMqP5gHCoxMIkhwpdDk2Nsbo6KgIXd5kZmdn+cMf/sCPf/xjfD4f3/72t7n77rvJzc1NtGiCq0QYOoEgyVEoFGRkZKBQKGSPLh6PL9guFsnE4OAgFy5c4OmnnyY3N5eysjI2bNhAWlragm2XtRARoUuBIMlRKBRYrVa5wa/U7Flw45BGH0lDkk+cOIHdbmfjxo3U1taK5tjzDOHRCQRJjkKhID8/n5SUFHlElEajEYvtDSQYDHLy5EmeeOIJWltbefDBB/nUpz5FXV2d8KTnIcKjEwiSHCl0mZqaSjweZ3p6Gr/fn2ixFiyzs7N0dnby5JNP4vF4aGxs5OMf/ziFhYUiXDlPEYZOIEhypNClXq8nHo8zOztLIBBItFgLDql/5dDQEGfPnuXw4cNYLBaamppobm4WBeHzGBG6FAiSHIVCQVZWFmazGaVSyejoKCUlJYkWa8ERi8WYnJzkP/7jP3j55Zex2+089thjbNy4UXhy8xxh6ASCeYBSqSQ1NZW0tDSmpqbw+XyJFmlBEQgEmJ6e5tvf/jYXLlwgJyeHr3zlKyxatGjBz2q7FRChS4EgyZEGaRoMBkwmE06nk2AwmGixFgRS/8qJiQnOnTvHgQMHAKivr2fNmjXYbLZ3NVdOkFwIj04gmCeYTCZsNhsTExN4vd5Ei7NgCAaDPPfcc/zP//wPTqeTRx99lA9+8INYLJZEiya4TghDJxDME4xGI5mZmUxOTgpDdx2QWnt973vf49ChQ3i9Xr71rW/R1NRERkYGIMKVCwVh6ASCeYLBYMBsNjM0NCSyLt8DUrH9zMwM/f39HDhwgGAwiN1uZ+3atWRnZ6PT6RIspeB6IgydQDBPMBqNZGVlMTExgc/nE23A3iNHjhzhmWee4ciRI3ziE5/gIx/5CKWlpWISwQJEGDqBYJ5gMpnIyspiamoKj8dDLBZDqVQKY3eNRCIRfv3rX7Njxw6OHDnCV7/6VTZs2EBNTY24lgsUsXURCOYJer0ei8VCKBTC7/eL8OW7wOVy0dfXx/79+5mamiI/P581a9ZQVlaG0WgUhm6BIgydQDBPMBqN2Gw2YrEYHo9HDGG9BqSJD/39/bz88ss888wzpKSk8Oijj7JmzRry8vISLaLgBiJClwLBPMFsNpOTk4NCocDpdDI+Pk5eXp7wQq6CeDzOsWPHeOGFF/jNb37DQw89xB133MGmTZtQq8UyuNAR37BAME/Q6XSYTCY0Gg2BQACn05lokeYFfr+fubk5du3axcWLF0lNTWXdunXU1tbKk9sFCxth6ASCeYJ0RqfX6/H7/UxPT4u5dG+DdG1mZ2c5d+4cP/nJT7DZbNxxxx3cc889GI3GBEsouFkIQycQzCOUSiW5ublEIhHGxsaEoXsHBgYGePnll/nhD3+I3W5n69atfPSjHyUlJSXRogluIsLQCQTzCGlkTzQaZW5uLtHiJC2RSAS/389rr73GiRMniEQibN68maamJrKyssS55i2GMHQCwTxCqVSSmZlJLBbD4XAIj+5NSNcjEAgwPj7Oz3/+c1wuF+Xl5XzsYx8jOztbFITfgohvXCCYRyiVSvLz84lGo4yPjydanKTE7XazZ88eHnnkEdxuN5s2beKHP/wh2dnZIsPyFkUYOoFgHqFUKklPTycWizE7Oys8ukuIxWJEIhF27tzJvn37mJiYYPPmzaxfv57c3FwxbucWRmxvBIJ5hEKhICMj4w2GTvS8fD1kGYlEcLvdPPfcc1y4cAG1Ws2DDz5IVVUVBoMh0SIKEojw6ASCeYRKpSI/P594PM7U1BTBYJBYLJZosRJOLBbj/PnzfPGLX+TIkSMUFRXxy1/+kkWLFom5cgLh0QkE8wmFQkF6ejo6nY5IJMLc3BwajeaW9Vik0O3Bgwc5duwYZ86cYf369TQ1NVFaWopOpxPJJwJh6ASC+YR0RqfX6+XwpdlsvmUNXSwWw+/3s2fPHo4ePcrU1BR33HEHy5cvJzMzM9HiCZIEYegEgnmEUqmkoKAAk8lENBpleHiYzMxMrFZrokVLCCMjI/z85z/nv//7v7FarTzxxBPccccdpKenJ1o0QRIhDJ1AMI9QKBQYDAZSUlLQaDTMzMzcsuN6zp8/z6lTp3jppZdoaGigoaGBpqYmTCaTCFcK3oDQBoFgHqFQKNDpdBgMBvR6PQ6Hg2AwmGixbiqxWAyfz8fZs2c5evQoXV1dNDY2smnTJsrLy9HpdIkWUZBkCI9OIJiHWCwWbDYbo6OjeL3eRItzU3G73Rw4cIDvf//7TE1N8Vd/9Vf8+Z//OUVFRYkWTZCkCEMnEMxDjEYjVquVqampWyp0OTo6SkdHB//+7/9OamoqdXV13HPPPWRlZYlwpeCKCM0QCOYhKSkpmM1m5ubmbonQZTweJxgM0t3dzcmTJzl+/DiFhYWsWrWKRYsWkZqammgRBUmM8OgEgnmI1WolKyuLlpYWfD5fosW54YRCIXp6evjBD37AsWPHWL16NY8++ijLli1LtGiCeYAwdALBPMRoNJKens7U1BR+vz/R4txQPB4PQ0NDfPvb32ZiYoJFixbxpS99CbvdLvpXCq4KEboUCOYhKSkpmEwmXC4XwWCQaDS64Bo8S/0rh4aG5AxLs9lMY2Mjq1atIi0tTRg5wVUhPDqBYB4iZV26XC7cbjd+v3/BnVPFYjGcTic/+9nP2L59OwaDgUceeYTNmzej1WoTLZ5gHiEMnUAwDzGZTPKk7NnZWYaHhzEYDMzNzeHxeJienmZ2dhar1cqWLVvQarWoVKpEi33VRCIRHA4H//zP/8zJkydJTU3la1/7GsuXL5cNuvDmBFfLLWnootEo4XCYzs5OIpHIG0I+oVCI3t5e3G434XCYU6dOvWVYo0qlwmAwUFhYuOB20YLkIhgM4vf7CQQChMNhIpEIwWCQ8fFxRkZGUCgUdHd3c+DAAXQ6HbOzs7jdbqanp3G5XBQXF3PnnXcm+mNcNdK9OD4+TmdnJ4cPHyYlJYX6+no5XCmGpwquFUV8oQX2rwKv18vk5CSf/OQnmZmZIRqNyr+Lx+N4vV6cTiehUIjS0tK3vD41NZWKigq+9rWvUVdXdzNFF9xiDA0N0d3dTX9/PzMzM8zMzDA0NMTY2BiTk5P09vbKZ3RvxmKxsG7dOl588cUESH7tSEtRLBbjF7/4Bc8++ywtLS185Stf4YMf/CBlZWXCixO8K27JrZFer5eHVzocDhwOh/y7eDwuTyqOx+P09va+5ebKzs5m8+bN6PX6my264Bajt7eX559/nldffVU2aH6/n2AwSDgcJhAIXHYenUKhoLi4+LIbtWTG5/Pxox/9iN27d9Pb28s3v/lN1qxZQ35+fqJFE8xjbklDp1Kp0Gq15OTkMDo6it/vv2LG2pVSt8vLy2/Z0SiCm4dWq8VoNDIwMEAgEECpVF5VhqVSqSQrKwubzXaTJH3vzMzMMDAwwIEDB/D5fJSXl7Nq1SoKCgrEplLwnrhlywtUKhXr1q3Dbrdfc+sgk8nEunXrbtnRKIKbR01NDQ888AB6vV5Ot38nI6dQKFAqlRQVFVFcXHyTJH0r8Xj8so8rPa+1tZVf//rXvPbaa5SXl/O5z32O+vp60tLSEiC9YCFxSxu6jRs3UlFRcdnQz5UoLCykurqaoqIiscsU3HBMJhPFxcVs2bKFqqqqq8qclAxiUVFRwkOX8Xic//zP/+SZZ57B6/Ve1tBFIhFefPFFnnrqKZ599lm5SfPq1atF/0rBdeGWDF3C67venJwcsrOzSUtLY3Z29qrCQYWFhZSVlaHVasXBuOCGI2X4rly5kunpaS5evHhVr4vH42RmZpKVlXWDJbwyoVAIh8PB0aNH0Wg0aDQa1q9fj8lkkuvgPB4PU1NT7Nq1i/HxcfLy8li7di12ux2z2Zww2QULi1t2u6RQKEhPTyc/P5/y8vKrSllWKBTU19fT2Nh4EyQUCF5Ho9Fw9913U1NTc9WvUSgU5ObmkpeXdwMle3tcLhdnz55l7969PP300/zjP/4jPT09smcXj8cZGxvj6NGj/OpXvyISifDggw+yadMmCgsLEya3YOFxy3p0EpWVlWzdupXz58+/4/lHPB6nsbGRlStX3kQJBbc6CoWC/Px8mpqa6OnpYdeuXQSDwSvqqkajIScnh/T09ITWeY6OjvLUU0/hdDrx+/309vby2GOP8b73vY9PfepTOBwOXnjhBZ566ik2b97M3Xffzfvf/37R9URw3bnlDZ3NZqO+vv4dzz40Gg02mw2bzSYOxwU3FYVCgUajoby8nNWrV7Nnz563fa5Op6OgoACDwZCwMy6fz8fk5CRtbW34/X6i0SiBQIDe3l6OHDmC2WwmHA5z8eJFDAYDt99+Ow0NDeLeEtwQbnlDl5ubKy8kCoXisrtkhUKBwWCgpqaG7OxsjEZjAiQV3OpUVlaiVqt5/PHHCQQCb6urFRUVpKSkJEDK15mbm2NkZIRz5869IdnL7XZz+PBhTp48SXp6Orm5uTQ2NvLhD39YnMkJbhi37BmdhF6vJzMzk+bmZgoKCq64AzaZTNx7773k5ubeZAkFgtexWq2UlZVx9913U1lZecUohMFgYPHixQk1HK+++ip79ux5y/0UjUYJhUL4fD4mJiaw2Wxs27YNvV4vkrsEN4xb3tAplUo0Gg2LFi0iOzv7ss+RdskNDQ1i1ylIGEqlEoPBwG233UZRUdFlDUM8HketVies/EUqbWhra+PChQuXLd2Jx+Nyv9ne3l527dpFa2srk5OTN11ewa3BLW/o4PUU7mXLll0xQ02lUpGamioMnSDhaLVaNm/eTGlp6WU9ung8jkajoaSkJCGde2KxGIFAgLa2Ns6fP3/FGlXJ2J07d45f/vKX7Nmzh97eXkKh0IKbqydIPMLQAWq1mk2bNl22zEClUlFXV8fKlSsxm82ic7ogoSiVSvLy8li9ejV33XXXW+o5pU1ZTU1NQs6SHQ4HL730EsPDw+84+VwqMQgEAvyf//N/+Jd/+Rd++ctfEg6Hb5K0glsFYeh4PTSZmppKfn4+drsdtVotLx7xeJzS0lLq6+tRKpXiHEGQUBQKBSqVipqaGjZs2PCWMzCLxUJmZiY6nS4hGZcul4t9+/bhdDqvyTPz+Xy0tbWxfft2zp8/z8zMzA2UUnCrIdwT/pSSnZ+fT01NDT09PW8Ye1JSUiLG8QiSCrvdTjweR6/XE4lEiEQiAKSlpWGz2VCpVDd9UxaNRpmdneXw4cO4XK5req1Go2F8fJxQKERPTw8Wi4WMjIwbJKngVkN4dJdQW1vL+973PuB1T04ygA0NDTQ1NSVYOoHgT0gZmPfddx9lZWWo1WrUajV2u/2aOqhcTwYGBmhvb6etrQ2Px3NVzaelBtRVVVX8xV/8Bb/4xS94//vfn9Bm1IKFh/DoLiEnJ4eamhr0ej3hcFjOxrTZbOh0ukSLJxDIKBQKUlJSuOuuuxgcHKS3t5dYLIbNZkvY7LazZ89y6tSpq3quQqHAarVit9tpaGhg3bp1VFRUyH1kRTNnwfXkljR0l04yjsVi8rDVlJQUcnJySE1NJRAIoNFoqK6uxmQyEYlEiEaj8i5UCg2JMztBIojH42i1Wpqbm3nxxRfRarX4fD7MZjNpaWlvSAS5VE8v9aKkM+f3qsNSUsn58+c5d+4cSqXyiiN5FAoFWq2W1NRUudPLli1b2LRpk2iULrhh3LKGLhaLMT09jcfjwe1243K5iMViuN1u6urqaG9vx+fzUVxczOjoKEeOHEGn05GamkpKSgoZGRmYTCY0Gk2iP47gFkTSYbVaTW1tLSMjI+zevZtYLMbc3ByvvfaavDHT6/VoNBrUajVarRaTyURqaipWqxWLxXJVo3/ejmg0itvt5tChQxw6dEg+L7wUaXNoMBhYtmwZd999Nx/5yEewWCyo1WrhwQluKAvO0MViMSKRCKOjozidTqanp5mYmMDlcjE7O4vD4cDv98uPUChEOBwmHA4Tj8cJh8N0dHQwNzdHJBLhhRdeYN++fRgMBlQqlXwWotfr5YfJZJINX0ZGBjabDYvFIk94TkRigGD+Eo1GiUQiDA8PMzc3x+zsLOPj4zidTpxOJzMzM/j9fgKBAH6/n+7ubkZHRwHYs2cP586dQ6PRyOfMKpVK9t5UKpVs9HQ6HSkpKej1elJTU8nKysJisWC1WsnOziY9PZ20tDSys7Pf1vPzer3s37+f6enptxg5SfdzcnJYvHgxt99+O+Xl5djtdiwWi/DiBDeFeWvopLCIZKT8fj/BYJBQKITH46G7u5upqSlGR0cZGxtjbm6O6elppqamZCN3aQjn0h2lwWCQjZ7b7cbtdsuhGCnUGY1GUSqVaLVa2ahZLBZsNhu5ublkZWWRn59PaWkpBoMBnU6HXq9Hq9Wi1WrfUMIguDWRdDgUChEKhQgGgwQCAYLBIF6vl46ODqamppicnGRkZASHw8Hs7CxTU1P4fD5CoZCsw2q1muzsbHw+H6Ojo7JhujSEeKkOSw+p24rRaCQnJ4e0tDQyMjLIy8uT5zWWl5ej0+nQaDTy5k6j0cieoNfrpaWl5S0zHTUaDWazGavVSmVlJRs3buSBBx4gMzNTDC0W3FQU8XnahkC6abu6uujv7+fw4cOcPXuWwcFBOjs7CYVCqNVqjEYjdrsdm81GQUEBJSUlWCwWLBYL2dnZmEwmTCYTVqtVNngGg4Hdu3fT19fHRz/6UdlLDIVCuN1uvF4v09PTOBwOXC4XU1NT9Pf3Mzk5ydDQEH19fXLH9oyMDPLz86msrGTlypXU1tZSV1dHXl6eCNfc4khG59y5c/T09HD69GmOHz/O4OAg/f39hEIhOVxeWVlJTk4OOTk5lJaWYrVaMZlMcvQA4OTJk6xYsYLCwkJSUlJQqVTE43F5AxiJRAiHwzidTjwej2w0XS4XMzMz9PT0MDExwejoKD09PXKUIz09nfLycsrKymhubmbp0qWUlZWRm5srn81t27aNiYkJgsEgKpWKWCxGQUEBW7Zs4bOf/SwlJSWkpaW94axQILhZzCtDFwqF6Ovro6Ojg4GBAc6dO8fY2Jg8yNFqtWI0GklPT6ekpASr1Up6ejpGoxG9Xo/BYCA1NVWedqzX61Gr1fL/SzefSqViYmICj8dDaWkp8KfEFalmSdqBRyIReQceCATw+Xy43W6cTieTk5MMDg7KZ4AOh0M+iK+qqqKkpISSkhKam5tlGQULG5/Px+DgIGfPnmVoaIiuri6Ghobk+XIZGRkYjUasVivl5eXyOZrRaMRgMMhhRklnJU8LYHZ2lvT0dNnISfocjUbfkHQVDodloxcMBuX/ejweAoEAgUAAp9OJw+FgZmaGgYEBXC4XXq8Xh8OBwWDAZDJRUVFBZmYmc3NzfO973yMQCGAwGKiurmbLli1UVVVRV1dHeXk5KSkpYs6cIGEkdehSMi5zc3N4PB6cTidnzpyhvb2d/v5+Ojo6iEQiaLVaCgsLKS8vJy8vj8rKSmpqauQzhndDTk4O8Xj8mruhSIuJ0+lkdHSU9vZ2RkZG6O/vl89XBgcHcTgcDA8PMzw8jEqlksNGaWlpGAwGkeSyQJA2Ry6XS/7+z58/z8mTJxkaGqK3t5dwOIzRaCQ3N5eKigoKCgrkbjxWq/Wq+6tardbL/vub29a9Uw9MKTQ/MzPD+Pg4586dY2BggOHhYfm8cHBwkOnpaYxGI36/H5/Ph16vJyMjg/r6eu68806qqqrIycm5KtkFghtJUnt0wWAQl8vF73//e/bu3cvp06fp6uqioKCA4uJiNm/ezMqVKykrK8Nut1/2Pd5tiOTSy3Kt73GlSxoKhRgYGKCjo4NXX32VM2fOcOHCBdxuN/X19TQ0NPDQQw/R0NBwxQbTgvmF3+9ncnKSl156iZdeeomOjg56e3spLy+X0+s3bdpEUVERRUVFl32Pmx3mu5L+SufWFy5c4OLFi+zcuZM9e/bQ399PJBKhrq6OhoYGHn74YVasWIHVahUhSkFSkHSGTkos2b9/PydOnKC1tZW+vj7MZjMZGRksX76cmpoa8vLyyMjIwGq1kpKSgsFgSOqbSjpT9Pv98hnf3NwcDoeDlpYW+vv7GR8fZ25ujpKSEsrKyti6dSu1tbVyK6Rk/nyCPxEKhXC5XBw8eJADBw5w8eJFBgcH5YzcRYsWsWTJErKysrBarWRkZMih9WRG0mGPx4PX62VkZIRjx44xMjICQEdHBzMzM/h8Pqqrq6msrOS2225jyZIlGI1Gob+ChJEUoUvpBpqampIzJQ8cOEBHRweDg4NyQondbpfTk+dbHzwpCy41NZXU1FRsNhvRaJRAIIDJZJK9u5aWFnp7e5mZmSE1NVWu5SsoKMBgMIjpCUmKFO6bnp5mdHRU1uHW1lYcDgdms5mamhrsdjtr1qxJ2HSB94Kkw2azGaPRKNfgzczMoFAoMBqNXLx4kTNnztDR0cHs7Czw+rXJy8sjOzub1NRUkYQluOkkhUcXj8cJhUI8/fTTvPLKK7z22mtEIhFWr17N+vXr+cQnPoHFYpHbcC2UneGbL30oFKK9vZ3nnnuOQ4cOsXfvXux2O4sXL+av//qvqaqqkjPsBMlFLBbD4/Hw9NNP87vf/Y5Tp04RiUTYunUrq1ev5qGHHnrDmKeFoMOXWzq8Xi+dnZ387Gc/48SJE7S0tFBXV8eaNWv45Cc/SUNDg0i6Etx0Emro4vE4fX19tLS08Oqrr3L8+HEyMzMpLy/n3nvvJT8/Xy66vhW6J8RiMXw+HzMzM0xPT9Pa2sru3bvp7e3F5/Nx++2309jYyAc+8AE5s06QWCKRCH19fezcuZPDhw9z4sQJSkpKKC8v5wMf+AD5+fmkp6eTlZUlF24vZKLRKH6/n4mJCSYmJujs7OT5559ncnKSQCDAtm3baGpq4rbbbiMlJWXBXw9BcnDT42CSXfV4PExOTrJ//35Onz7N+fPnSU9Pp7a2lqamJlatWoXRaLylmikrlUqMRqOcgWe1WvH7/aSkpHDs2DHa29vx+/1YLBYWLVpEWlravAt/LQQkHZ6dnWVycpJ9+/Zx7Ngxuru7sdlsLFmyhCVLlrBq1apbLoNWpVLJOpyTk4PNZmNycpL29nZaW1s5ffo04XAYlUpFY2MjJpOJlJSURIstWODcVI/u0g4N7e3tvPjii3zve99Dr9dTVVXFN7/5TUpLS8nOzr5ZIiU98XicmZkZXnnlFX7yk5/Q09ODRqPhG9/4Bk1NTVRXVwMLIxQ2H7hUhw8ePMjOnTv57ne/S15eHrW1tXzjG9+gqKjoXZe1LDSk6zUwMMD+/ft5/PHHmZ2dRa/X88QTT1BfX09JSQkgdFhw47iphi4cDuPz+fjud7/L6dOnaW1tZcuWLTQ3N7N+/Xpyc3PRarW31A74nZCSHFwul1wk//Of/5ypqSmKi4v50Ic+xN133y0W1ptEMBjE6XTyL//yL5w5c4bBwUHuuusuNmzYwNKlS8nNzZV7SQre2KpPas139OhRnn/+eSYmJmhsbGTLli3cf//94uxOcMO4KXej1IZobGyMU6dOcfLkSVwuFzU1Naxbt45FixZRXl4OiF3dm1EoFKjVatLT0+U+g8PDw+zatQuXy8WuXbvIy8vDbreLnfENJB6PEwgE6O3tpa2tjVOnThGPx6mtrWX9+vUsWbJE7qIjrv+fkK6FVqslLS2N2tpaeUrIH//4R8bGxti9ezclJSWUlpaSm5v7htcJBNeDG27oLj3POHr0KN/61rfw+/2sW7eOz33uczQ0NNxS53DvhZSUFKqrq/nqV79KSUkJu3fv5he/+AWhUIjNmzfz8Y9/HLVaLXetF1wfpPKX6elpduzYwU9/+lN8Ph8f/vCH+fCHP8yiRYtEYtBVIJUgNDc3s2zZMmw2Gy+//DJPP/00sViMe++9l61btwodFlx3bnjoUuoM8bd/+7d0dXURDAb5x3/8R+rq6iguLkan0wmFvgakr8vtdjM4OMj+/fv50Y9+hMFgYPXq1fzN3/wNGRkZYuG9jrjdbiYmJvjCF77AxMQECoWCf/7nf8Zut5OTkyN0+BqRdNjlcnH+/HmOHTvGk08+SWlpKU1NTfz93/89BoNBZGQKrhs31KMLBAKMjIzwyiuvMDAwQEpKCrfffrvc4krE5K8daUE1m80UFhbS3NwsnxUdP36cQ4cOUVdXR0VFxRueL7h2pHBld3c3+/fvZ2xsjLy8PBobG6mtrSUtLU3o8LtA0kmLxUJ5eTkKhYKWlhYmJydlHa6pqaGgoOANzxcI3i03ZMskhXqcTidtbW088cQTBINBli9fzle/+lXKyspITU29EX/6lsJisdDY2Mijjz7K2rVrOX/+PE8//fQVpzwLrp5LQ+5Hjhzh+9//Pjqdjk2bNvHlL3+ZnJycpG/ZNR+w2WysWLGCL3zhC1RWVtLa2sovf/lL2traiEajiRZPsEC4IR6dlHzyne98h+PHj6PRaPj7v/97li5ditlsFju060x9fT1Go5GCggK++c1vMjMzg9vt5pOf/KTYULxLpPZsX/nKV+jp6SElJYV/+7d/o7y8HJPJJHT4OqJUKlmyZAkajYaGhga+/vWvEwwGGR4e5hOf+ITIYBW8Z26IR+dyudi3bx8XLlwgGo1y3333UV1dTWZm5jWPvRG8PQqFAq1WS3Z2NsuWLaOpqQm1Ws3OnTvp7+9nbm4u0SLOS6ampti3bx8XL17EaDRy7733UlZWJg/oFTp8/VAoFOh0OgoLC1m+fDlNTU24XC727t3L0NAQXq830SIK5jnX3dBFo1Gmpqb43e9+x/DwMFlZWTz22GMUFRWJ84wbiMVioa6ujvvuu4/c3Fz27NlDa2srExMTcihZ8M7E43EikQgDAwM8++yzTE9PY7fb+cxnPkNmZqbIEL6BZGVl0dDQwAMPPIBKpWLv3r20tbXhcDiEDgveE9c9JnD27FkOHjzIr3/9a774xS+yYcMG8vPzRQbVTUChUHDPPfeg1+uZmZnhn/7pn/izP/sz/vIv/xKTyZRo8eYNx44d4+WXX+a3v/0tX//611m1ahV5eXlCh28COp2OBx98EL/fD8D/9//9f3zta1/j3nvvFe3uBO+a62bopMnaLS0tnDhxArvdztKlS6murr5pqe4Oh4O+vj5eeumlt/xOq9ViMpn46Ec/+paJzdKZotSz8M3ce++9VFdXMzExwcDAAFNTU4yMjODxeIjFYmi1WiwWi9yQuqKiAr1ef9PDW1IIqKqqinvuuYd//dd/pauri8OHD3P77beLjjPvgNSFRgpZ2u12GhsbKS0tvSk6LNXqnTt3jgMHDrzl93q9nvT0dD72sY+h1Wrf8LtYLEYoFOL555+ns7PzLa99+OGHKSoqku9Th8NBd3c3XV1duFwuvF6v3KcyLS2NRYsWYbPZbvosRIVCgV6vp7GxkWAwyOOPP865c+fIz8/ntttuEyFjwbviuhm6WCyG1+vl2LFjtLa2snLlShoaGiguLr5ef+IdmZub49y5czz55JP4/X4ikQjhcBidTkdaWhrFxcXcd999bzF08PqIHKkmzev1olQqUalU6HQ6KisrKSoqoq2tjZaWFrq7uzl//jwzMzNEo1H0ej2ZmZmUlpayYcMGMjIy5GGaiaCkpASLxcKPfvQjhoaG2L17N2vXrr0luue/FyKRCD6fj3379uFyuVi5ciX19fXYbLabJoPD4eDo0aM8+eST+Hw+IpEIkUgEvV6PzWajoqKChx566C2GTtqsbd++ne3bt8uGS61Wo9Vq2bJlC4WFhcDrdYF9fX3s2bOH/fv3MzExwczMjNy9JDc3F5/PR2NjI1arNSE1mfX19ZjNZn7wgx/Q0dFBamoq69atk2fiCQTXwnUrGJ+ZmeE3v/kNP/vZz1CpVDz11FPk5eXd1M7ksViMSCRCIBDg8ccf5+DBg+zdu5dHHnmEjRs38sEPfvCyhajSJQgGg0xNTfH5z3+evLw8Kisr+fjHP47b7ebcuXM88MADVFdXs2jRIj772c+Sm5uLSqXC4XDws5/9jFOnTnHs2DE+9rGPsXnzZh544IGb9tnf/HkikQj/+Z//yWuvvcaxY8fYsWMHhYWFYp7d29Df38/27dt54oknWLx4Mf/6r/9KcXHxTfOEJW8rEong9Xr5+te/zuHDh2lra+Mzn/mM3FMzJSXlLYu9pMOBQICLFy/yta99jerqampra3nwwQcxGAwoFAr8fj9f+tKX6Orqwuv18qUvfYnKykoKCwuZnZ3l4MGDvPjii+zZs4dHHnmExx57DLvdftONXTwex+1281//9V8899xzOBwOXnjhBbKzs8W0A8E1c12295JS7tq1i/T0dJYuXYrNZnvLrvNGo1Qq5RDl0qVLqampAaCrq4uxsTH5Zn8z0i5RoVAQi8Xo6+sjMzOT5cuXYzabUalUcrr5unXruOeeeygrKyMrK4vMzEwKCwv5wAc+wPr161EqlbS0tHDu3DkikUhCDtAVCgUqlYpVq1ZRUVGBUqnk6NGjDA0N3XRZ5gOXtvjatWsX5eXlNDQ0kJ2dfVMXeOl70+l0mM1mmpqaKCkpIRqNcv78eRwOxxVr9y71dEKhEL29vZSUlLB48WJMJhNqtZrJyUm2b9/O+fPnMRgMPPLIIyxdupSSkhLS0tLIy8ujqamJD33oQyiVSiKRCLFY7KZ9/jd/Hr1ez7p16ygsLCQajXLo0CGmpqYSIo9gfnNdDF04HGZubo6WlhZyc3NZsmSJfHMliurqaux2O2q1mosXL9Lf308gEHhbw+Pz+ZienmZ8fByr1UpVVZW8+Oj1egoKCtiwYQO33347mZmZGAwGdDodFouFtWvX0tTURGpqKh0dHfT19SXM0MHrC0VdXZ2cEn/8+HGGh4dF9toVCAaDcmeOyspK6urqMJlMCQv1KpVK6uvrKSwsRKlUcv78eUZHRwkGg2/7OrfbzfT0NGNjY+Tm5lJWVga8Hu2YmJjgj3/8IxMTE9hsNh544AEqKirIyMhAo9FgMpmorq5my5YtsvFTq9UJCxVKdXXFxcUYDAaOHDnC9PS00GHBNXNd7uKuri6OHz/O6OgoK1as4I477rgeb/uuUSgUVFdXyzfJ3NwcXV1dHDly5G0XinPnzvHaa6+xYsUKeQGA17s3bNy4kY6ODj7wgQ+Qmpr6hptfmjCQmpoqd18PBoPvuCjdaNRqNbW1tWzdupVXX32VCxcuiI4pV6CtrY3Tp08zOjrK7bffzqpVqxIqj0KhYNGiRdTV1VFYWMjU1BTnz5+npaXlbTuGtLS0cOzYMdasWSMbq3g8ztzcHB0dHfzmN79hyZIlrFmzRq5rvRS1Wk1mZiZHjx7lH/7hH+QWXYlCo9GwYsUK1qxZw/PPP8/g4KDomCK4Zq6Loevu7qajo4PS0lIKCwvJysq6Hm/7nlAqlWRkZLBmzRoMBgOTk5McPHiQQCBwxdf09/dz6tQpVq5cSV5e3htCmpJXp1KpLns+EgwGcbvdTE1NkZmZic1mu2Ko9GYgyV1QUMCqVavwer0MDQ3R3d0tdsOXob29naGhIcrKyigoKCA9PT2h8igUCpRKJfn5+TQ3N6NWqxkYGODo0aNvu9BfuHCBrq4u1q5dS3p6uqx/3d3d9PT0EA6HKS4ufoN+v/nvStm7Go0mocXxkiwVFRU0NjbidDrp7++nv78/IfII5i/XxdANDw8zODhIcXExmZmZSdMiyWq1smzZMgwGAw6HgzNnzhAIBN5y7iA17x0dHaWvr49FixaRmZn5ju9/afLLyMgIY2NjeL1eysrKKCoqQqvVJvw6ZGZmUl1dLU8qHxgYSNi5SzLT29vL1NQUJSUlZGRkJE3rtJycHJYuXYparWZ0dJTW1tbLhsRjsRiBQICBgQHGx8fldnsSQ0NDcug6KyuL1NRUpqamGBgYoLe3l+7ubvr6+hgZGWF6ejqh53NvRpq3GI1GmZiYYHh4ONEiCeYZ1+UQra+vj/7+ft73vvclfCd8KTk5Odxzzz38+7//O729vezatYvp6WksFssbMrei0Sjt7e309/fj9XpZv379VRWn+v1+nE4nfX19/OhHP+LixYtkZWXx13/91yxatOhGfrSrxmg0kpeXR1FRER6Ph9bWVjZt2pRosZKOjo4Opqen5azGZKG8vBydTsd3vvMd+vr68Hq9zM3NoVar39ClJRgM0tbWxsjICLFYjI0bN74hW7Svr4/BwUHgdZ0YGBhg+/bt7Nixg6mpKdxuN1lZWbL39PnPf56MjIykaFxttVrJz8+nqKiI8fFxLly4wIYNGxItlmAe8Z4MnVQ7Nz09jdvtprKyMqm6F+h0OjIyMqipqSEQCDA+Ps6JEydQKBTU19fLz4tEIhw4cAClUklzczNarfZtkxAcDgd79+5l165dDA8P4/V6iUQilJeX8/DDD9PQ0HBVHuHNQAq72u12wuEwPT09InR5CVLt3OTkJKFQiMrKyqRq82UwGMjKyqKuro6LFy/i8/k4cuQIy5Ytkyeaw+ubrr1795Kenk5paelbkkjcbjcejweAZ555BpvNhtls5rOf/axcrnDx4kW6u7t59dVXmZubY+vWrdx5550JDcHDn/q5VlZW4vF4ROhScM28p9BlLBbD7XbjdrsJhUJJN2NOpVKRkpKC3W4nLy+PSCRCe3v7G0IfUs1Za2srKpWKhoaGd8w0i0QiTE9P09fXR09PD8PDwygUCkwmEzabjVgsRjgcvhkf8apQKBRykozU+1LwOtFoFI/HIxuB/Pz8pOogo9FoMBqNVFVVkZGRQTAYpLW19Q1p9rFYDL/fz+nTp0lLS6O6uvotZ2uBQEBOjpLuAZvNxqZNm9i2bRv3338/t912G4WFhbhcLl599VVOnTrF+Ph4UuiLWq0mPz+fQCDA9PR0osURzDPek6GLRqOMj4/j9/vRaDSUlJQkRajjUhQKBZs2baKxsZF4PM5rr71GW1ub/PtIJILH42Hnzp0YDAbe9773vWPtVFZWFp/+9Kf5wx/+wMGDB3nuuefYsGEDg4OD/K//9b944okn2LNnz43+aFeNUqmksLAQhUKRNAtXshAKhRgbGyMUCqHX6ykpKbnp9Z/vhFqt5q677qKqqopQKMRLL71ET0+P/PtIJMLs7Cw7duygqKiIjRs3vuU9wuGwvPnSarUsXbqUb3zjG9TW1sre3Z133smDDz7IRz7yESYnJ9m3bx+//e1vk2LTptFoKCoqkps6CATXwnsOXbpcLsLhMEqlEpPJlFS7YYnFixfT29tLSkoK/f399PT0MDg4SH5+PiMjI7S1tcmF30VFRe8YppF+L5UUFBYW8tBDD2G323G5XOzcuROv10tJSQk1NTUJD4VJ3ia8HsIShu5PRKNRnE4n0WgUtVqd0Nq5K6FSqVi+fDlHjhxBp9PR09NDb28vIyMj5OXl0d3dTWtrK7m5uRQVFZGXl/eW99BqtbIBr66ufkP/zkv1PTc3lxUrVqBWqxkbG+Ps2bNJkZQirS9S1xiB4Fp4T3e0lK0YjUZRKpXo9fqkWyTgdQ8sNzeXnJwcfD4f4+Pj9PX1EY1GmZyc5MKFCxQUFGCz2TAajVd9HqFUKuXQklRkXFVVxdjYmHzekQy7YanLBJDw2r5kQ8pWjMVisg4nOlP2zSgUCnJycsjNzcVms+FyuRgdHWVgYIB4PM7w8LDcCUXKGH3zZ9Dr9fKGKzMz84pz9aTkJaVSidvtTppQt0KhwGAwEI1GhQ4Lrpn3bOiCwSCxWEyuvUk2Q6dQKNBoNBQUFLBp0yYMBgP9/f28/PLLBINBuru72b17N5s2bcJut7+nvyXV7aWkpDA1NcXhw4eT5qaUDN07dYe51YjFYrIOK5XKpNbhiooK1q9fj0qlor29nV27dhGLxTh79izHjx9n69at8lnsm8nIyJAzoo1G4xUzS/V6vWwEA4EATqczKfRFMnTS9yUQXAvv6Y6WwglqtVpOTEnGzhsKhYL8/Hze9773YTAYGBoaYufOnQwMDNDT08PFixdZt27de560IGWHKRQKwuEwbrc7KcI+Ui9SIGlqHJMFlUqFyWSS+5m63e6k7LwhFU5v3rwZtVpNZ2cne/bsYXh4mIsXLzI6OsqmTZvIzs6+7OvLy8spKSkBXp/yIenDmwkEAszNzRGLxTAYDFit1qTQF+mYRDouEAiuhfdk6KRdlkqlIhaL4fP5knKRgNcX+MrKSiwWC+FwmMHBQU6cOCE3e87Nzb3icNKxsTE6OjpobW3F5XJd8W+Ew2F5dI+U8ZkMiwS83scTSLpkoUSjVCpJSUlBqVQSjUbx+XxJ4cFcjszMTOx2OyaTCZ/PR39/Py0tLczNzZGSkvK2Wc/5+fnk5+ej0+mYnp5mdnaWaDT6ls/q9XoZGxsjFothNpvJzc1NCh2Ox+Py6KFkyuwWzA/eUzLKpQko0qG+1WpNysVUKhIvLi7G7XYzOTnJk08+ic1mo7m5GYvFcsVsuz179nDs2DGmp6f50pe+RGNj42WfNzs7y4kTJ/D7/RQUFFBZWZkUyTnxeFw20NdyBnkroFar5QkV4XAYp9NJZmZmUnxvb0bqTVlcXCwnozz++ONkZ2ezbNmyt02kqampYXx8nMzMTDo7O7Hb7YRCobckSo2NjXH8+HEikQiFhYU0NTUlZB7dm5HWF+HRCd4N78mjU6vV8oyzeDxOZ2dnUmdEKZVKNm/eTH19PbFYjM7OTsxmM3fdddc7Lmwej4cdO3bw1FNP8cwzzzA2NobP58Pn8zE2NsZTTz3FT3/6U15++WXZeN59991JcVNGo1G6urqIx+OUlpYKQ3cJOp2OwsJCjEYjwWCQzs7OpD4D0ul03HXXXZSVlREOhzl//jzFxcVs2rTpit+r1HS8urqav/u7vyM1NZWjR4/yt3/7t5w7d46JiQk5W/iZZ57h17/+NWVlZWzatIn77rsvoVNIJEKhEJ2dnaSkpFBUVJRocQTzjPekwQqFgpSUFCwWCwaDgeHhYfx+//WS7bojja7p6upCoVAQj8fJyMigqqrqbXeteXl5VFdX09rayvT0NKdPn8bv96PVauWQSmtrK2NjY+Tl5bF69WpWrlx50+eZXQ5pmOfo6GhShaKSBSl0abVacTqdDA0NJUWm7JVQqVQsXryYkydPyjqcm5tLeXn5275OqVSSlpZGU1MTq1evZnJyku7ubnbu3InFYkGj0dDT08Po6ChpaWmsXbuWpUuXkp2dnXB9kZo6DA8PU1xcfFMnvgsWBu/Z0Gk0GrKzs8nKyqKjo4NNmzYRj8cTfnNcDoVCQXNzM+3t7Wi1WrKysigtLaWuru5t5W1ubqa8vJyMjAwOHTrE0aNH+e1vf8vMzAzhcBi1Wk1xcTGlpaV89KMf5aGHHkrI4NkrEY1G6enpYdmyZdjt9qTLKkwkUop9fn4+0WiUjo4OgsFg0uqwVqtl7dq17Nq1C51OR1ZWFna7naqqqnd8rdlsZunSpfzv//2/OXHiBL/73e/4v//3/+L1egmHwxQWFlJXV8f999/PZz7zmaSpi5Wyu7u6uqivr5eTagSCq+W6xCTsdjsjIyPs27ePBx54QD7gTsaFIi0tjU996lPce++9qFQq0tLS3lFOnU5HTk4OH/zgB7nrrrvkLhPSYb5k8DUaDQaDAbPZnBThHkBugutwOMjKyqKxsVEYustQX18v94v8/Oc/n7Ser0KhICMjg3/4h3/gC1/4AiqVCpvNdk2yVlVVUVxczJ133imXm8TjcTQaDVqtFoPBgMViSRo9GRgYoLW1FafTSXFx8Rv61AoEV8N1WY2Li4spLy/n97//PaOjo0xNTSVleEE6q8jIyJCHql4NSqUSpVKJ1WrFarXeOAFvAJOTk7S3t8t9OJN1AU80drud0dFR/vjHPzI6OkpWVlbSNOa+FEmHc3JyyMnJeVev1+v1cr3cfGBoaIiuri6sVis5OTlJubYIkpvrYuiqqqrwer04nU66u7spKysTyphgJK96cHCQw4cPU1hYSHFx8RULim91lixZwvj4OE6nk46ODtLS0pLS0N1KSDrc2dnJ6dOn5TmPV6oVFAiuxHWJTWRkZFBWVsaKFSs4ceIE27dvvx5vK3iPTE5O0trayv79+9m2bRu1tbWJFikpUSgU2Gw2KioqWL58Oa+++ir79u1LtFi3PLFYjImJCY4fP87p06f50Ic+RGFhYaLFEsxDrouhU6lUmM1mbrvtNrxeLxcuXGBwcJBAIHA93l7wLohGo7S0tNDf349KpWLp0qXCm3sb1Go1WVlZbNiwgbGxMTo7OxkcHEzqDMyFTjAY5NChQ0xMTKDX61m+fHlSDXYWzB+u22mzyWRi27ZtxGIxurq6aG1txePxJG2XiYWMNA9vx44d9Pb2kpWVxfLlyy/b1V7wJ2w2G9u2bWNubk7uhBMKhYQOJwBpqPP27duZmZkhJyeHpqYmYegE74rrZuhSUlJYsWIFGzZsIC8vj29961tcvHhR7IgTwMzMDKdOneKFF14gNTWVz33uc3I/R8GVsVqtNDU1sXHjRpRKJf/0T//ExMREUvZvXeiMjIxw4sQJ/vCHP1BZWcmnPvWppJ2OIkh+rpvWSA2NV61axcqVKxkfH+fIkSOcOnXqev0JwTsQj8cJhUJ0dXXxhz/8AYvFQmVlJcuXL3/HqemC17NrtVotmzZtoq6ujrGxMfbv38+FCxcSLdotg6TDp0+f5pVXXsFms1FfX8/ixYtRKBRChwXviuu+PWpubmbdunVEo1EOHTrEoUOH5DEoghuHFF5zOp20tbXx/PPPU1ZWxqJFi6irqxPe3DVw2223sWzZMiKRCDt37uTUqVMihHkTkOr5ZmdnaWlp4bXXXqOuro5FixZdVUG8QHAlFPHrfPfGYjGmpqb44x//yBNPPIFGo+Fv/uZv2Lhxo4iv30CkNklf+cpXOH36NP39/Tz77LOUlpaSlpYGJGcBf7IhLbZ9fX3s3buXf/zHf6ShoYHPfvazbNmyJSkbli8UpObjX/7yl2lrayMQCPDMM8+Qm5uL0WgEhA4L3h3XvX2HUqnEbDazcuVKmpub6e3t5amnniI9PZ3q6mqR+XeDGBoa4tixY7S0tGA2m/mzP/szCgoKxLSCa0QKj2VlZck67HK5+O///m+5FlHU190YLly4wMmTJzl58iTl5eUsXryY7OzspJz6Lphf3JCTXYPBQE1NDWvWrKG4uJg9e/Zw4sQJuru7RRjzOiJ5Hx6Ph4sXL/Liiy8yPj4utytLS0tLmn6b8w2z2UxNTQ3r16/HbDazd+9eTp06xeDgoNwLU/DekXTY5XLR2trKyy+/zPT0NFVVVWzbti1p+m0K5jfXPXR5KaFQiHPnzvH4449z7Ngxqqur+epXv8ry5cuTYnzNfEdaJJ588kn27dvHq6++yuOPP05zczONjY3i8P49Eo/HCYfD7Nmzh//6r//iwIED3HXXXTzyyCM0NzeLBfg6IDVsfvzxx9m1axfnzp3ju9/9Lk1NTVRWVgodFlwXbmjnYY1GQ3FxMY888giRSITp6WmefPJJPv3pT1NVVUVZWdmN/PMLFmn0zuDgILt27eKll14C4KMf/SirV6+msLBQpGFfJzQaDXV1dXz84x9nbm6OwcFBfvjDHxKLxbDb7aI28V0Sj8eJRqO0t7dz+PBhXnnlFaxWKw899BDNzc3k5OQIHRZcN26ooVMoFKSlpbFx40ZaW1s5cuQIBw8epK6ujnA4jMViwWq1yqNSBO9MLBYjGo3KzZq3b9/O8PAwdXV1bNu2jcrKSuEtXycknczLyyMjI4OjR49y7NgxDh06xJIlS4jFYnJzZOF5XD2xWIxIJML4+DinTp3i5ZdfZnx8nEWLFrF161bKy8uTZvqHYGFwQ0OX8Ke092g0SltbG7/4xS/49a9/TW5uLnfffTef+9znyMjIEOnvV0kgEGBiYoKvf/3rnD59moGBAR5//HFWrFhBQ0ODWHBvAJIORyIR9u3bx3PPPccvfvELli9fzubNm/mrv/or9Hq90OGrxOPxMDExwZe//GU6OzuZnZ3lBz/4AUuWLKG8vFzosOC6c8O3TdIUZJVKJQ8m1ev1XLx4kT/+8Y/4fD6am5u57bbbyMzMFOGKt+HChQucP3+eZ599lv7+fgoLC3n44YdZt24d2dnZ4trdICQdVqvVNDQ0yF1menp6ePHFF/F6vWzcuJGlS5eSmZkpFukrEI/HaW1t5cSJE+zcuZORkREaGxtZtWoVTU1NZGRkCB0W3BBuSnxAuvGtViuNjY3Mzs6i1+vp6enhwIEDhEIhLBYL9fX1mM1mUlNTxa7u/xEOhwkGg0xPT3PixAlOnz7NkSNHsNvtNDQ0sG3bNoqKikR25Q1G0sXs7GzS09OZnp5mx44djIyMsHv3bnQ6HSqVirq6Osxms5wSf6vrsFTf6fP5cDgcHD16lJaWFjk5bdmyZWzdupWCggLhEQtuGDc8dPlmLu3gMTg4yJe+9CW6u7uZm5vjscceY9OmTaxfvx6tVnvLLxIAExMTdHR08G//9m8cPXoUjUbD+9//fr74xS9SVlaGTqcDRCHtzUTS4ampKXp7e/nCF77A8PAw0WiURx99lG3btrFo0SI0Gs0t/73E43FGR0c5duwYP/vZz9i7dy8FBQVs3LiRv/u7vyMzM1POXr3Vr5XgxnHTDZ1EOBzG7/fT1tZGW1sbLS0ttLa2kpmZSWlpKffeey9VVVUUFRXdcjtjn8/HzMwMu3fv5sCBAwwMDDA3N8fatWupqalh5cqVlJWVkZKSIkI9CSQYDOLz+WhtbaWlpUXW5eLiYkpLS/nABz5AXV0dWVlZt5wOezweRkdHOXz4MDt27GBiYgKPx8Mdd9xBTU0NixcvpqKiAq1WK3RYcMNJWGqTRqNBrVbT3NxMeno6er2eoaEhZmdnmZ2dJSMjg7m5Oebm5sjNzcVkMi3ocFAkEiEUCjE1NcXY2BhDQ0NyQ+FAIEBVVRXr16+nrq6OysrKRIsrAHQ6HVqtljVr1mAwGDCbzQwMDDA6OsrMzAxmsxmfz0dxcTHZ2dmYzeYFvbCHw2ECgQAOh4OBgQF6e3vZv38/nZ2daLVa7HY7mzZtwm63U1xcnGhxBbcQCfPoJKQ/H4/HGR8fZ8+ePbz00kv84Q9/wGQyUVBQwKOPPsrKlSuprKxcsCHN2dlZRkdH+dWvfsVrr73GxYsX0ev13H///axbt44PfehD8gSChfj55zOXZhaPj4/z7LPPsm/fPrZv347NZqO8vJyHH36Y2267jby8PDncvNCQQrnPPvsszz33HJOTk+j1ej7xiU+wZs0a7rzzThGmFCSEhBs6CWk8x9zcHNPT05w7d46zZ8/S3t5OX18faWlp2Gw21q9fz9KlSyktLSUvL29e3jBSsezw8DB9fX3s3r2bjo4OhoeH8fv9VFZWYrfb2bx5M3l5eaSlpd2S4a/5hqTDU1NTTE9Pc+HCBY4cOUJPTw+Dg4PYbDby8vJobm5m9erV5Ofnk52dnWix3xWSDnd3d9Pf38/+/ftpbW1lenqaQCAghyZXr15NcXExVquVtLQ0ocOChJA0VZkKhQKdTkd2djZZWVmkp6djMplITU3F7/fjdrsZHBzkyJEjOJ1Oent7KS8vx2q1kpqaSlpaGikpKUk5d00q8nY6nXg8HtxuN1NTU/T399Pf38+ZM2eYnZ0lEolgt9tpamqivr6e1atXo9FoRDbaPEHS4YKCAnJycsjKykKpVGKxWAgGg7jdbvr6+ojFYgSDQfLz8ykqKiI9PZ3U1FQsFgupqalJ2UBBKvJ2Op24XC48Hg9TU1N0dXUxNDREa2srMzMzKBQKKioqWLlyJbW1tTQ3Ny/ocK1gfpA0Ht2ViEajTE9Pc/jwYY4fP85vf/tbJiYmCIVClJaWsnr1ampra9mwYQMVFRWYTKYr3lQ3cvF4u8sYDofx+XwcOXKEc+fOcebMGXbt2oXL5SIWi7Fq1SrWr19PU1MTt99+uzBuC4xwOIzD4WDHjh2cOHGC7du3Mzo6ilqtprCwkNtvv526ujpWrFhBTU3N207SvlE6/E7LgGSojx49yokTJ2hvb2fv3r243W50Oh1NTU1s3bqVxYsXs27dOtRqtTBugqQh6Q2dVIfj8Xjwer3MzMzQ29vL0NAQZ86coa+vj9nZWUKhEFarlfT0dOx2O5WVldhsNgoKCigsLMRkMmE2m2+YjLFYDJ/Px/T0NENDQ0xOTjI4OMiFCxcYHx9nbGwMt9uN0WgkIyODuro67HY7paWllJWVYTabSUlJwWw2i/DOAkPSYafTic/nY3Z2lgsXLjA0NMSFCxfo7OzE4/EQDodJT08nOzuboqIiamtryc7OJicnh6KiIjnCcaNkjMViuFwuOZlkbGyM0dFRzp8/z+joKNPT07jdbtLT00lPT6e2tpba2loKCgooLi7GYrGQkpIij4YSOixIFpLe0F2K1K1/dHSUiYkJWltb6ezsZHx8nOHhYYLBIEqlUj4PMJlMpKenk5OTg9lslm9EjUaDRqNBr9ejVqvlhxQyUqlU8o0aiUTkvxuNRolGo0QiEYLBIKFQSP75UkM8Pj6Oy+Vibm4Oh8NBIBAgEAhgtVrJycmhoKCAJUuWUFpaSmFhIRkZGWJRuEWQdEkyJB0dHbS1tTE5OcnExAR+vx+dTofZbCY9PR2z2YzVaiUvLw+z2YzJZHpbHZb0VqVSoVQqZb29VIcjkYic5RsKhQiHw4RCIdxut6y3o6OjuFwuXC4XMzMzBAIBIpEIVquVwsJCcnNzWbx4MZWVlWRnZ8vnbwJBMjKvDN2V8Pl89Pb2cvbsWfr7+2lra+Ps2bNMTU3hcDgA0Gq1GI1GSkpKsFgsWCwWcnJyMJlM8kNaLAwGg7xo+Hw+eXHw+XzyY2Jigrm5OVwuF5OTkwwNDeHz+YhEIqjVaiwWCwUFBaxYsYLS0lKqqqpYsWIFVqsVk8mU4CsmSDakBgrHjx+nr6+Pzs5OTp48icPhwOl0Aq/PebxUh81ms7yJS01NxWg0ymU7er0ejUZDPB5/gw77/X48Hg8ej4eZmRlmZmZwOp3MzMzQ399PMBgkGo2iVqvJysoiNzeX5uZmKioqKCsrk3VYTFoXzCcWhKGLxWKEQiGCwaBcyxMMBgkEArhcLvr7+3E4HExOTjI9PS0bq7m5Ofx+P36/X96xSokC0WgUeL1WSqlUolKp0Ol0cu2UxWLBaDTK9VM2mw2r1Upubi6FhYWkpqai1+sxGAxoNBq0Wi0Gg0HeaQsElxKNRmXdlTytQCCAz+eTk1imp6dxOBxMTU3h9Xrx+/04nU68Xq+s71LUIRQKEY1GUSgUcjKIWq1Gq9Wi1+vR6/UYjUbMZjMGgwGTyUROTg7p6elkZWVRUlKCwWBAp9NhMBjQarVoNBoMBgNKpVLosGBesSAM3ZWQdrATExPy2cPMzAw+n09eJKSworRISEZTCvdcaui0Wi1arRadTiefl0iLREZGBmazmYyMDGw2G1qtViSUCN4zksEbGxvD6XTidDrlzVogEMDpdOL3+wkGg/IGTTJ0sVgM4A2GTgp36nQ6UlNTMZlMGAwGUlNTsdls8uis7Oxs1Gq10GHBgmBBGzqBQCAQCET8QSAQCAQLGmHoBAKBQLCgEYZOIBAIBAsaYegEAoFAsKARhk4gEAgECxph6AQCgUCwoBGGTiAQCAQLGmHoBAKBQLCgEYZOIBAIBAsaYegEAoFAsKARhk4gEAgECxph6AQCgUCwoBGGTiAQCAQLGmHoBAKBQLCgEYZOIBAIBAsaYegEAoFAsKD5/wEfBKPAuxP4+gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Input a csv file with the edges in the graph with the columns: node_1,node_2,time_lag\n", "file_path = \"../datasets/temporal_graph.csv\"\n", @@ -104,7 +126,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -113,9 +135,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parents of the target node with respective time lags: ['V5', 'V7'] [(1,), (3, 5)]\n", + "Ancestors of the target node: ['V4']\n" + ] + } + ], "source": [ "# the outcome node for which effect estimation has to be done, node:6\n", "target_node = 'V6'\n", @@ -129,18 +160,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIIAAAAUCAYAAABBPOWjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAABJ0AAASdAHeZh94AAAEvUlEQVR4nO2aa6gVVRTHf5pQcisFJaWgbmZahKlUYE+L0ugFRkFf1CywJCIS75ci+PsvfAQ9JIweCFkWWCAZvSm4KhY9NUJ6k0qB+dbyRWW3D3tOHs+ZmbvnnBntgz+47Dl7z157rXXX3rP3munT09PDMY7R92grcIz/B/1qF7avBLrr2r6XdE5jB9svAtcBZ0raW7WCti8AvgCmS1p0BMY7ovaVSZ6vbA8GttbXSepTu+5HMyuBFcC2lIEuAqYAXY1Osn0rMB4YA4wGTgJekTS5sEWHK/ul7eXAI7aXStrTjrw8suyz/ShwITACGAzsBzYCy4GFkrZXpM8G4IyM5s2ShtZX9OKrfYCT62mNctMCYYWk2RmDzwF+B55JaXuIEAB7gF+BptWkDeYBnwL3AXNLlNtIln0zgTXAB8AWoAMYB8wG7rI9TtIvFem0G1iQUp81IVJ9JWkfQd/a6t9rIKRiewRwDbBI0v6UW2YSAuAnwsrQnXJPS0j6zPZ3wN2250v6pyzZNXqx72RJB1L6zAEeBB4A7ilbp4RdOROziVZ9VWSzeCfQB3g1Q4FuST9KquoYshQ4HZhQkfxM+9KCIOG1pDy7Ip1apbCvolcEwmw5CHxSUKmy+CgpJwDvVyC/FftuSsqvy1fnP463PZnwj92bjLVK0sGcPoV9FRUItjsIm8Bvj+JO+vOkvKJswbH22e4CTgQGEDaPlxH+MfPL1qmOocCShrr1tu+QtDKjT2FfxT4aTgOOAzbFCi4bSbuBA4SZUTax9nUBAu4nBMF7wERJW/M6tcELwNWEYOgARgHPAZ3Au7ZHp3VqxVexj4ZBSbkzVnBF7ACGVCA3yr7acc32EOASwkqw1vaNktaUrZQkN1StA2bY3gPMIpwCbs7oXshXsStCbRd9QqzgiujPIV3KpJB9kjZLeh2YSAiilyrQKY9nkzJv6S/kq9hA2JKUg3LvqhDbfYGBdbqUSUv2SdoIfAOcl2TujhS1R1FHWmMrvooNhE3J4CNjBVfASMLx7qsKZLdj36lJmbeLL5txSflzRnthX0UFQpIbWAUMtj08Vnhv2F5su8f2tIjba8Y3JaoKymkizz7bI2wPSBmzb5JQOgX4WNLOhva2dLJ9bnKaaazvBBYmP1/O6J7pqyyK5BGWAbcA1xKyh4dhexIwKflZy4FfbHtxcr1NUldDt1og/h0x/kTCrHsjpa2InCyy7LsemGd7NbAe2E7YhI0HhgG/AdMr0Ok2YJbtVYT3Gn8AZwE3EPYy7wCPZfTN81UqRQNhCzAVeDqlfQxwe0PdsOQPgjGNgTCKYODbeQMnM3IS8FZGTj9KTi9k2fchMJxwXBxLePbuBX4gnO+fkrSjAp26CUv8WOBSwn5gF7A6GXdJWhY3wlepRAeCpD9tLwDm2h4raW1D+2ySlxox2B4InA883rispjCVMAuaZkBBOZlk2SdpHXBvEVll6JQki7ISRnlk+iqPtECQbZH+PcKTwAzgYQ6lV1vlcuAv4Im8m2z3J7zUWSZpdatyIinLvjJ1iibPV2nfI9RTHwgbOPS+GlK+R5B0wPYU4CrbHe2kmyW9Sdy5vRN4HljcppwYnUqxr0ydCtJJtq/qv0do4l8+xOrKvQBRugAAAABJRU5ErkJggg==", + "text/latex": [ + "$\\displaystyle \\left[ \\left( 1,\\right), \\ \\left( 3, \\ 5\\right)\\right]$" + ], + "text/plain": [ + "[(1,), (3, 5)]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "time_lags" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "TypeError", + "evalue": "int() argument must be a string, a bytes-like object or a real number, not 'tuple'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m time_shifted_df \u001b[38;5;241m=\u001b[39m \u001b[43mshift_columns_by_lag\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdataframe\u001b[49m\u001b[43m,\u001b[49m\u001b[43mparents\u001b[49m\u001b[43m,\u001b[49m\u001b[43mtime_lags\u001b[49m\u001b[43m,\u001b[49m\u001b[43mancestors\u001b[49m\u001b[43m,\u001b[49m\u001b[38;5;28;43mfilter\u001b[39;49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild_node\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtarget_node\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2\u001b[0m time_shifted_df\u001b[38;5;241m.\u001b[39mhead()\n", + "File \u001b[0;32m~/home/dowhy/dowhy/timeseries/temporal_shift.py:78\u001b[0m, in \u001b[0;36mshift_columns_by_lag\u001b[0;34m(df, columns, lag, ancestors, filter, child_node)\u001b[0m\n\u001b[1;32m 76\u001b[0m new_df \u001b[38;5;241m=\u001b[39m df\u001b[38;5;241m.\u001b[39mcopy()\n\u001b[1;32m 77\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m column, max_lag \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(columns, lag):\n\u001b[0;32m---> 78\u001b[0m max_lag \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mmax_lag\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 79\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m shift \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m1\u001b[39m, max_lag \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m 80\u001b[0m new_column_name \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mcolumn\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m_lag\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mshift\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n", + "\u001b[0;31mTypeError\u001b[0m: int() argument must be a string, a bytes-like object or a real number, not 'tuple'" + ] + } + ], "source": [ "time_shifted_df = shift_columns_by_lag(dataframe,parents,time_lags,ancestors,filter=True, child_node=target_node)\n", "time_shifted_df.head()" @@ -159,10 +218,21 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "['V5', 'V5_lag1']" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# inlcude specific treatments\n", - "treatment = 'V7'\n", + "treatment = 'V5'\n", "treatment_columns = [treatment] + [f\"{treatment}_lag{i}\" for i in range(1, int(time_lags[parents.index(treatment)] + 1) ) ]\n", "treatment_columns" ] @@ -171,7 +241,18 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "['V5', 'V7', 'V5_lag1', 'V7_lag1', 'V7_lag2', 'V7_lag3', 'V4']" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# include all the treatments\n", "treatment_columns = list(time_shifted_df.columns)\n", @@ -183,7 +264,38 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/t-ashutoshs/home/dowhy/dowhy/causal_model.py:583: UserWarning: 3 variables are assumed unobserved because they are not in the dataset. Configure the logging level to `logging.WARNING` or higher for additional details.\n", + " warnings.warn(\n" + ] + }, + { + "ename": "NetworkXError", + "evalue": "The node V5_lag1 is not in the digraph.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/networkx/classes/digraph.py:908\u001b[0m, in \u001b[0;36mDiGraph.successors\u001b[0;34m(self, n)\u001b[0m\n\u001b[1;32m 907\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 908\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28miter\u001b[39m(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_succ\u001b[49m\u001b[43m[\u001b[49m\u001b[43mn\u001b[49m\u001b[43m]\u001b[49m)\n\u001b[1;32m 909\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n", + "\u001b[0;31mKeyError\u001b[0m: 'V5_lag1'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mNetworkXError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[22], line 12\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mdowhy\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m CausalModel\n\u001b[1;32m 5\u001b[0m model \u001b[38;5;241m=\u001b[39m CausalModel(\n\u001b[1;32m 6\u001b[0m data\u001b[38;5;241m=\u001b[39mtime_shifted_df,\n\u001b[1;32m 7\u001b[0m treatment\u001b[38;5;241m=\u001b[39mtreatment_columns,\n\u001b[1;32m 8\u001b[0m outcome\u001b[38;5;241m=\u001b[39mtarget_node,\n\u001b[1;32m 9\u001b[0m graph\u001b[38;5;241m=\u001b[39mgraph\n\u001b[1;32m 10\u001b[0m )\n\u001b[0;32m---> 12\u001b[0m identified_estimand \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43midentify_effect\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 14\u001b[0m estimate \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mestimate_effect(identified_estimand,\n\u001b[1;32m 15\u001b[0m method_name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbackdoor.linear_regression\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 16\u001b[0m test_significance\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 18\u001b[0m common_causes \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39m_common_causes\n", + "File \u001b[0;32m~/home/dowhy/dowhy/causal_model.py:240\u001b[0m, in \u001b[0;36mCausalModel.identify_effect\u001b[0;34m(self, estimand_type, method_name, proceed_when_unidentifiable, optimize_backdoor)\u001b[0m\n\u001b[1;32m 233\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 234\u001b[0m identifier \u001b[38;5;241m=\u001b[39m AutoIdentifier(\n\u001b[1;32m 235\u001b[0m estimand_type\u001b[38;5;241m=\u001b[39mestimand_type,\n\u001b[1;32m 236\u001b[0m backdoor_adjustment\u001b[38;5;241m=\u001b[39mBackdoorAdjustment(method_name),\n\u001b[1;32m 237\u001b[0m optimize_backdoor\u001b[38;5;241m=\u001b[39moptimize_backdoor,\n\u001b[1;32m 238\u001b[0m )\n\u001b[0;32m--> 240\u001b[0m identified_estimand \u001b[38;5;241m=\u001b[39m \u001b[43midentifier\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43midentify_effect\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 241\u001b[0m \u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_graph\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 242\u001b[0m \u001b[43m \u001b[49m\u001b[43maction_nodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_treatment\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 243\u001b[0m \u001b[43m \u001b[49m\u001b[43moutcome_nodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_outcome\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 244\u001b[0m \u001b[43m \u001b[49m\u001b[43mobserved_nodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_graph\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_all_nodes\u001b[49m\u001b[43m(\u001b[49m\u001b[43minclude_unobserved\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 245\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 247\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39midentifier \u001b[38;5;241m=\u001b[39m identifier\n\u001b[1;32m 249\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m identified_estimand\n", + "File \u001b[0;32m~/home/dowhy/dowhy/causal_identifier/auto_identifier.py:101\u001b[0m, in \u001b[0;36mAutoIdentifier.identify_effect\u001b[0;34m(self, graph, action_nodes, outcome_nodes, observed_nodes, conditional_node_names)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21midentify_effect\u001b[39m(\n\u001b[1;32m 94\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 95\u001b[0m graph: nx\u001b[38;5;241m.\u001b[39mDiGraph,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 99\u001b[0m conditional_node_names: List[\u001b[38;5;28mstr\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 100\u001b[0m ):\n\u001b[0;32m--> 101\u001b[0m estimand \u001b[38;5;241m=\u001b[39m \u001b[43midentify_effect_auto\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 102\u001b[0m \u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 103\u001b[0m \u001b[43m \u001b[49m\u001b[43maction_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 104\u001b[0m \u001b[43m \u001b[49m\u001b[43moutcome_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 105\u001b[0m \u001b[43m \u001b[49m\u001b[43mobserved_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 106\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mestimand_type\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 107\u001b[0m \u001b[43m \u001b[49m\u001b[43mconditional_node_names\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 108\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackdoor_adjustment\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 109\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimize_backdoor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 110\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcosts\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 111\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 113\u001b[0m estimand\u001b[38;5;241m.\u001b[39midentifier \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\n\u001b[1;32m 115\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m estimand\n", + "File \u001b[0;32m~/home/dowhy/dowhy/causal_identifier/auto_identifier.py:178\u001b[0m, in \u001b[0;36midentify_effect_auto\u001b[0;34m(graph, action_nodes, outcome_nodes, observed_nodes, estimand_type, conditional_node_names, backdoor_adjustment, optimize_backdoor, costs)\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m IdentifiedEstimand(\n\u001b[1;32m 172\u001b[0m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 173\u001b[0m treatment_variable\u001b[38;5;241m=\u001b[39maction_nodes,\n\u001b[1;32m 174\u001b[0m outcome_variable\u001b[38;5;241m=\u001b[39moutcome_nodes,\n\u001b[1;32m 175\u001b[0m no_directed_path\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m 176\u001b[0m )\n\u001b[1;32m 177\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m estimand_type \u001b[38;5;241m==\u001b[39m EstimandType\u001b[38;5;241m.\u001b[39mNONPARAMETRIC_ATE:\n\u001b[0;32m--> 178\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43midentify_ate_effect\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 179\u001b[0m \u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 180\u001b[0m \u001b[43m \u001b[49m\u001b[43maction_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 181\u001b[0m \u001b[43m \u001b[49m\u001b[43moutcome_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 182\u001b[0m \u001b[43m \u001b[49m\u001b[43mobserved_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 183\u001b[0m \u001b[43m \u001b[49m\u001b[43mbackdoor_adjustment\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 184\u001b[0m \u001b[43m \u001b[49m\u001b[43moptimize_backdoor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 185\u001b[0m \u001b[43m \u001b[49m\u001b[43mestimand_type\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 186\u001b[0m \u001b[43m \u001b[49m\u001b[43mcosts\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 187\u001b[0m \u001b[43m \u001b[49m\u001b[43mconditional_node_names\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 188\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 189\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m estimand_type \u001b[38;5;241m==\u001b[39m EstimandType\u001b[38;5;241m.\u001b[39mNONPARAMETRIC_NDE:\n\u001b[1;32m 190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m identify_nde_effect(\n\u001b[1;32m 191\u001b[0m graph, action_nodes, outcome_nodes, observed_nodes, backdoor_adjustment, estimand_type\n\u001b[1;32m 192\u001b[0m )\n", + "File \u001b[0;32m~/home/dowhy/dowhy/causal_identifier/auto_identifier.py:231\u001b[0m, in \u001b[0;36midentify_ate_effect\u001b[0;34m(graph, action_nodes, outcome_nodes, observed_nodes, backdoor_adjustment, optimize_backdoor, estimand_type, costs, conditional_node_names)\u001b[0m\n\u001b[1;32m 228\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m backdoor_adjustment \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m EFFICIENT_METHODS:\n\u001b[1;32m 229\u001b[0m \u001b[38;5;66;03m# First, checking if there are any valid backdoor adjustment sets\u001b[39;00m\n\u001b[1;32m 230\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m optimize_backdoor \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m:\n\u001b[0;32m--> 231\u001b[0m backdoor_sets \u001b[38;5;241m=\u001b[39m \u001b[43midentify_backdoor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maction_nodes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutcome_nodes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mobserved_nodes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbackdoor_adjustment\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 232\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 233\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mdowhy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcausal_identifier\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mbackdoor\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Backdoor\n", + "File \u001b[0;32m~/home/dowhy/dowhy/causal_identifier/auto_identifier.py:499\u001b[0m, in \u001b[0;36midentify_backdoor\u001b[0;34m(graph, action_nodes, outcome_nodes, observed_nodes, backdoor_adjustment, include_unobserved, dseparation_algo, direct_effect)\u001b[0m\n\u001b[1;32m 497\u001b[0m backdoor_paths \u001b[38;5;241m=\u001b[39m get_backdoor_paths(graph, action_nodes, outcome_nodes)\n\u001b[1;32m 498\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m dseparation_algo \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdefault\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m--> 499\u001b[0m bdoor_graph \u001b[38;5;241m=\u001b[39m \u001b[43mdo_surgery\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 500\u001b[0m \u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 501\u001b[0m \u001b[43m \u001b[49m\u001b[43maction_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 502\u001b[0m \u001b[43m \u001b[49m\u001b[43mtarget_node_names\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutcome_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 503\u001b[0m \u001b[43m \u001b[49m\u001b[43mremove_outgoing_edges\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 504\u001b[0m \u001b[43m \u001b[49m\u001b[43mremove_only_direct_edges_to_target\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdirect_effect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 505\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 506\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 507\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124md-separation algorithm \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdseparation_algo\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m is not supported\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/home/dowhy/dowhy/graph.py:136\u001b[0m, in \u001b[0;36mdo_surgery\u001b[0;34m(graph, node_names, remove_outgoing_edges, remove_incoming_edges, target_node_names, remove_only_direct_edges_to_target)\u001b[0m\n\u001b[1;32m 134\u001b[0m new_graph\u001b[38;5;241m.\u001b[39mremove_edges_from([(node_name, v) \u001b[38;5;28;01mfor\u001b[39;00m v \u001b[38;5;129;01min\u001b[39;00m target_node_names])\n\u001b[1;32m 135\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 136\u001b[0m children \u001b[38;5;241m=\u001b[39m \u001b[43mnew_graph\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msuccessors\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnode_name\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 137\u001b[0m edges_bunch \u001b[38;5;241m=\u001b[39m [(node_name, child) \u001b[38;5;28;01mfor\u001b[39;00m child \u001b[38;5;129;01min\u001b[39;00m children]\n\u001b[1;32m 138\u001b[0m new_graph\u001b[38;5;241m.\u001b[39mremove_edges_from(edges_bunch)\n", + "File \u001b[0;32m~/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/networkx/classes/digraph.py:910\u001b[0m, in \u001b[0;36mDiGraph.successors\u001b[0;34m(self, n)\u001b[0m\n\u001b[1;32m 908\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28miter\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_succ[n])\n\u001b[1;32m 909\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[0;32m--> 910\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m NetworkXError(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe node \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mn\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m is not in the digraph.\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merr\u001b[39;00m\n", + "\u001b[0;31mNetworkXError\u001b[0m: The node V5_lag1 is not in the digraph." + ] + } + ], "source": [ "# perform causal effect estimation on this new dataset\n", "import dowhy\n", @@ -192,7 +304,8 @@ "model = CausalModel(\n", " data=time_shifted_df,\n", " treatment=treatment_columns,\n", - " outcome=target_node\n", + " outcome=target_node,\n", + " graph=graph\n", ")\n", "\n", "identified_estimand = model.identify_effect()\n", @@ -201,6 +314,9 @@ " method_name=\"backdoor.linear_regression\",\n", " test_significance=True)\n", "\n", + "common_causes = model._common_causes\n", + "# estimate v5t effect on v6t\n", + "\n", "print(estimate)" ] }, @@ -309,7 +425,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.10.14" } }, "nbformat": 4, diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py index 99e0b4d79..643441f17 100644 --- a/dowhy/utils/timeseries.py +++ b/dowhy/utils/timeseries.py @@ -39,7 +39,7 @@ def create_graph_from_user() -> nx.DiGraph: continue node1, node2, time_lag = edge try: - time_lag = float(time_lag) + time_lag = int(time_lag) except ValueError: print("Invalid weight. Please enter a numerical value for the time_lag.") continue @@ -80,9 +80,9 @@ def create_graph_from_csv(file_path: str) -> nx.DiGraph: # Add edges with time lag to the graph for index, row in df.iterrows(): - # add validation for the time lag column to be a number + # Add validation for the time lag column to be a number try: - row["time_lag"] = float(row["time_lag"]) + time_lag = int(row["time_lag"]) except ValueError: print( "Invalid weight. Please enter a numerical value for the time_lag for the edge between {} and {}.".format( @@ -90,7 +90,18 @@ def create_graph_from_csv(file_path: str) -> nx.DiGraph: ) ) return None - graph.add_edge(row["node1"], row["node2"], time_lag=row["time_lag"]) + + # Check if the edge already exists + if graph.has_edge(row["node1"], row["node2"]): + # If the edge exists, append the time_lag to the existing tuple + current_time_lag = graph[row["node1"]][row["node2"]]["time_lag"] + if isinstance(current_time_lag, tuple): + graph[row["node1"]][row["node2"]]["time_lag"] = current_time_lag + (time_lag,) + else: + graph[row["node1"]][row["node2"]]["time_lag"] = (current_time_lag, time_lag) + else: + # If the edge does not exist, create a new edge with a tuple containing the time_lag + graph.add_edge(row["node1"], row["node2"], time_lag=(time_lag,)) return graph @@ -118,7 +129,7 @@ def create_graph_from_dot_format(file_path: str) -> nx.DiGraph: for u, v, data in multi_graph.edges(data=True): if "label" in data: try: - time_lag = float(data["label"]) + time_lag = int(data["label"]) # Handle multiple edges between the same nodes if graph.has_edge(u, v): @@ -175,9 +186,11 @@ def create_graph_from_networkx_array(array: np.ndarray, var_names: list) -> nx.D elif array[i, j, 0] == "<--": graph.add_edge(var_names[j], var_names[i], type="contemporaneous", direction="backward") elif array[i, j, 0] == "o-o": + # raise error graph.add_edge(var_names[i], var_names[j], type="adjacency", style="circle") graph.add_edge(var_names[j], var_names[i], type="adjacency", style="circle") elif array[i, j, 0] == "x-x": + # raise dag error / not supported / conflicting graph.add_edge(var_names[i], var_names[j], type="conflicting", style="cross") graph.add_edge(var_names[j], var_names[i], type="conflicting", style="cross") From 139eeaa98535fd6cf8463e256b5561d3471ef339 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Wed, 31 Jul 2024 06:07:41 +0000 Subject: [PATCH 50/67] multiple time lags --- .../datasets/temporal_dataset.csv | 6 +- .../effect_inference_timeseries_data.ipynb | 267 ++++++++++++++---- dowhy/timeseries/temporal_shift.py | 83 +++++- dowhy/utils/timeseries.py | 40 +++ 4 files changed, 334 insertions(+), 62 deletions(-) diff --git a/docs/source/example_notebooks/datasets/temporal_dataset.csv b/docs/source/example_notebooks/datasets/temporal_dataset.csv index f58cf5796..d29e7b27e 100644 --- a/docs/source/example_notebooks/datasets/temporal_dataset.csv +++ b/docs/source/example_notebooks/datasets/temporal_dataset.csv @@ -8,4 +8,8 @@ V1,V2,V3,V4,V5,V6,V7 6,7,1,2,4,5,9 12,3,5,7,3,8,9 3,2,1,6,3,8,9 -4,6,3,5,8,9,1 \ No newline at end of file +4,6,3,5,8,9,1 +3,5,9,6,2,1,3 +5,2,6,8,11,3,4 +2,2,4,1,1,4,6 +5,6,4,3,4,6,2 \ No newline at end of file diff --git a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index cf8870242..f9e048bc7 100644 --- a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -17,7 +17,7 @@ "source": [ "import networkx as nx\n", "import pandas as pd\n", - "from dowhy.utils.timeseries import create_graph_from_csv,create_graph_from_user\n", + "from dowhy.utils.timeseries import create_graph_from_csv,create_graph_from_user, unroll_graph\n", "from dowhy.utils.plotting import plot, pretty_print_graph" ] }, @@ -85,7 +85,8 @@ "| V2 | V3 | 4 |\n", "| V5 | V6 | 1 |\n", "| V4 | V7 | 4 |\n", - "| V7 | V6 | 3 |" + "| V7 | V6 | 3 |\n", + "| V7 | V6 | 5 |" ] }, { @@ -130,7 +131,7 @@ "metadata": {}, "outputs": [], "source": [ - "from dowhy.timeseries.temporal_shift import find_lagged_parents,shift_columns_by_lag, find_ancestors" + "from dowhy.timeseries.temporal_shift import find_lagged_parents,shift_columns_by_lag, find_ancestors,reverse_bfs_with_accumulated_lags,shift_columns_by_lag_using_unrolled_graph" ] }, { @@ -188,67 +189,172 @@ "metadata": {}, "outputs": [ { - "ename": "TypeError", - "evalue": "int() argument must be a string, a bytes-like object or a real number, not 'tuple'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m time_shifted_df \u001b[38;5;241m=\u001b[39m \u001b[43mshift_columns_by_lag\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdataframe\u001b[49m\u001b[43m,\u001b[49m\u001b[43mparents\u001b[49m\u001b[43m,\u001b[49m\u001b[43mtime_lags\u001b[49m\u001b[43m,\u001b[49m\u001b[43mancestors\u001b[49m\u001b[43m,\u001b[49m\u001b[38;5;28;43mfilter\u001b[39;49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild_node\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtarget_node\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2\u001b[0m time_shifted_df\u001b[38;5;241m.\u001b[39mhead()\n", - "File \u001b[0;32m~/home/dowhy/dowhy/timeseries/temporal_shift.py:78\u001b[0m, in \u001b[0;36mshift_columns_by_lag\u001b[0;34m(df, columns, lag, ancestors, filter, child_node)\u001b[0m\n\u001b[1;32m 76\u001b[0m new_df \u001b[38;5;241m=\u001b[39m df\u001b[38;5;241m.\u001b[39mcopy()\n\u001b[1;32m 77\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m column, max_lag \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(columns, lag):\n\u001b[0;32m---> 78\u001b[0m max_lag \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mmax_lag\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 79\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m shift \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m1\u001b[39m, max_lag \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m 80\u001b[0m new_column_name \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mcolumn\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m_lag\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mshift\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n", - "\u001b[0;31mTypeError\u001b[0m: int() argument must be a string, a bytes-like object or a real number, not 'tuple'" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "time_shifted_df = shift_columns_by_lag(dataframe,parents,time_lags,ancestors,filter=True, child_node=target_node)\n", - "time_shifted_df.head()" + "updated_graph = reverse_bfs_with_accumulated_lags(graph, target_node)\n", + "unrolled_graph = unroll_graph(updated_graph)\n", + "plot(unrolled_graph)" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 9, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'time_lag': (3, 7, 9)}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "## Causal Effect Estimation\n", - "\n", - "Once you have the new dataframe, causal effect estimation can be performed on the target node with respect to the action nodes." + "updated_graph.get_edge_data('V4','V6')" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
V6_0V5_-1V7_-3V7_-5V4_-3V4_-7V4_-9
06000000
17500000
28600000
39770400
49880500
\n", + "
" + ], "text/plain": [ - "['V5', 'V5_lag1']" + " V6_0 V5_-1 V7_-3 V7_-5 V4_-3 V4_-7 V4_-9\n", + "0 6 0 0 0 0 0 0\n", + "1 7 5 0 0 0 0 0\n", + "2 8 6 0 0 0 0 0\n", + "3 9 7 7 0 4 0 0\n", + "4 9 8 8 0 5 0 0" ] }, - "execution_count": 20, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# inlcude specific treatments\n", - "treatment = 'V5'\n", - "treatment_columns = [treatment] + [f\"{treatment}_lag{i}\" for i in range(1, int(time_lags[parents.index(treatment)] + 1) ) ]\n", - "treatment_columns" + "time_shifted_df = shift_columns_by_lag_using_unrolled_graph(dataframe, unrolled_graph)\n", + "time_shifted_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Causal Effect Estimation\n", + "\n", + "Once you have the new dataframe, causal effect estimation can be performed on the target node with respect to the action nodes." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['V5', 'V7', 'V5_lag1', 'V7_lag1', 'V7_lag2', 'V7_lag3', 'V4']" + "['V5_-1', 'V7_-3', 'V7_-5', 'V4_-3', 'V4_-7', 'V4_-9']" ] }, - "execution_count": 21, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -256,43 +362,90 @@ "source": [ "# include all the treatments\n", "treatment_columns = list(time_shifted_df.columns)\n", - "treatment_columns.remove(target_node)\n", + "treatment_columns.remove(target_node+\"_0\")\n", "treatment_columns" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/home/t-ashutoshs/home/dowhy/dowhy/causal_model.py:583: UserWarning: 3 variables are assumed unobserved because they are not in the dataset. Configure the logging level to `logging.WARNING` or higher for additional details.\n", - " warnings.warn(\n" + "*** Causal Estimate ***\n", + "\n", + "## Identified estimand\n", + "Estimand type: EstimandType.NONPARAMETRIC_ATE\n", + "\n", + "### Estimand : 1\n", + "Estimand name: backdoor\n", + "Estimand expression:\n", + " d \n", + "────────(E[V₆ ₀])\n", + "d[V₅ ₋₁] \n", + "Estimand assumption 1, Unconfoundedness: If U→{V5_-1} and U→V6_0 then P(V6_0|V5_-1,,U) = P(V6_0|V5_-1,)\n", + "\n", + "## Realized estimand\n", + "b: V6_0~V5_-1+V5_-1*V4_-3+V5_-1*V7_-5+V5_-1*V4_-9+V5_-1*V7_-3+V5_-1*V4_-7\n", + "Target units: \n", + "\n", + "## Estimate\n", + "Mean value: 0.11805104580947834\n", + "p-value: [0.18613988]\n", + "### Conditional Estimates\n", + "__categorical__V4_-3 __categorical__V7_-5 __categorical__V4_-9 __categorical__V7_-3 __categorical__V4_-7\n", + "(-0.001, 0.6] (-0.001, 5.4] (-0.001, 5.4] (-0.001, 0.6] (-0.001, 1.8] 0.489469\n", + "(0.6, 4.2] (-0.001, 5.4] (-0.001, 5.4] (5.4, 7.8] (-0.001, 1.8] 0.284098\n", + " (5.4, 7.8] (-0.001, 5.4] (7.8, 9.0] (5.4, 7.0] 0.230999\n", + " (9.0, 10.0] (-0.001, 5.4] (0.6, 5.4] (1.8, 5.4] 0.471972\n", + "(4.2, 5.8] (-0.001, 5.4] (-0.001, 5.4] (7.8, 9.0] (-0.001, 1.8] 0.205896\n", + " (7.8, 9.0] (5.4, 7.0] (0.6, 5.4] (-0.001, 1.8] -0.228553\n", + "(5.8, 6.4] (5.4, 7.8] (-0.001, 5.4] (7.8, 9.0] (-0.001, 1.8] 0.250684\n", + " (7.8, 9.0] (5.4, 7.0] (0.6, 5.4] (1.8, 5.4] -0.322592\n", + " (7.8, 9.0] (5.4, 7.0] -0.324498\n", + "(6.4, 7.0] (-0.001, 5.4] (-0.001, 5.4] (7.8, 9.0] (5.4, 7.0] -0.467333\n", + " (7.8, 9.0] (-0.001, 5.4] (5.4, 7.8] (1.8, 5.4] -0.106417\n", + " (9.0, 10.0] (-0.001, 1.8] 0.190052\n", + "dtype: float64\n" ] }, { - "ename": "NetworkXError", - "evalue": "The node V5_lag1 is not in the digraph.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/networkx/classes/digraph.py:908\u001b[0m, in \u001b[0;36mDiGraph.successors\u001b[0;34m(self, n)\u001b[0m\n\u001b[1;32m 907\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 908\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28miter\u001b[39m(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_succ\u001b[49m\u001b[43m[\u001b[49m\u001b[43mn\u001b[49m\u001b[43m]\u001b[49m)\n\u001b[1;32m 909\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n", - "\u001b[0;31mKeyError\u001b[0m: 'V5_lag1'", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mNetworkXError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[22], line 12\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mdowhy\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m CausalModel\n\u001b[1;32m 5\u001b[0m model \u001b[38;5;241m=\u001b[39m CausalModel(\n\u001b[1;32m 6\u001b[0m data\u001b[38;5;241m=\u001b[39mtime_shifted_df,\n\u001b[1;32m 7\u001b[0m treatment\u001b[38;5;241m=\u001b[39mtreatment_columns,\n\u001b[1;32m 8\u001b[0m outcome\u001b[38;5;241m=\u001b[39mtarget_node,\n\u001b[1;32m 9\u001b[0m graph\u001b[38;5;241m=\u001b[39mgraph\n\u001b[1;32m 10\u001b[0m )\n\u001b[0;32m---> 12\u001b[0m identified_estimand \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43midentify_effect\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 14\u001b[0m estimate \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mestimate_effect(identified_estimand,\n\u001b[1;32m 15\u001b[0m method_name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbackdoor.linear_regression\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 16\u001b[0m test_significance\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 18\u001b[0m common_causes \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39m_common_causes\n", - "File \u001b[0;32m~/home/dowhy/dowhy/causal_model.py:240\u001b[0m, in \u001b[0;36mCausalModel.identify_effect\u001b[0;34m(self, estimand_type, method_name, proceed_when_unidentifiable, optimize_backdoor)\u001b[0m\n\u001b[1;32m 233\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 234\u001b[0m identifier \u001b[38;5;241m=\u001b[39m AutoIdentifier(\n\u001b[1;32m 235\u001b[0m estimand_type\u001b[38;5;241m=\u001b[39mestimand_type,\n\u001b[1;32m 236\u001b[0m backdoor_adjustment\u001b[38;5;241m=\u001b[39mBackdoorAdjustment(method_name),\n\u001b[1;32m 237\u001b[0m optimize_backdoor\u001b[38;5;241m=\u001b[39moptimize_backdoor,\n\u001b[1;32m 238\u001b[0m )\n\u001b[0;32m--> 240\u001b[0m identified_estimand \u001b[38;5;241m=\u001b[39m \u001b[43midentifier\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43midentify_effect\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 241\u001b[0m \u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_graph\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 242\u001b[0m \u001b[43m \u001b[49m\u001b[43maction_nodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_treatment\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 243\u001b[0m \u001b[43m \u001b[49m\u001b[43moutcome_nodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_outcome\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 244\u001b[0m \u001b[43m \u001b[49m\u001b[43mobserved_nodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_graph\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_all_nodes\u001b[49m\u001b[43m(\u001b[49m\u001b[43minclude_unobserved\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 245\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 247\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39midentifier \u001b[38;5;241m=\u001b[39m identifier\n\u001b[1;32m 249\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m identified_estimand\n", - "File \u001b[0;32m~/home/dowhy/dowhy/causal_identifier/auto_identifier.py:101\u001b[0m, in \u001b[0;36mAutoIdentifier.identify_effect\u001b[0;34m(self, graph, action_nodes, outcome_nodes, observed_nodes, conditional_node_names)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21midentify_effect\u001b[39m(\n\u001b[1;32m 94\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 95\u001b[0m graph: nx\u001b[38;5;241m.\u001b[39mDiGraph,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 99\u001b[0m conditional_node_names: List[\u001b[38;5;28mstr\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 100\u001b[0m ):\n\u001b[0;32m--> 101\u001b[0m estimand \u001b[38;5;241m=\u001b[39m \u001b[43midentify_effect_auto\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 102\u001b[0m \u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 103\u001b[0m \u001b[43m \u001b[49m\u001b[43maction_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 104\u001b[0m \u001b[43m \u001b[49m\u001b[43moutcome_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 105\u001b[0m \u001b[43m \u001b[49m\u001b[43mobserved_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 106\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mestimand_type\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 107\u001b[0m \u001b[43m \u001b[49m\u001b[43mconditional_node_names\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 108\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackdoor_adjustment\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 109\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimize_backdoor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 110\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcosts\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 111\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 113\u001b[0m estimand\u001b[38;5;241m.\u001b[39midentifier \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\n\u001b[1;32m 115\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m estimand\n", - "File \u001b[0;32m~/home/dowhy/dowhy/causal_identifier/auto_identifier.py:178\u001b[0m, in \u001b[0;36midentify_effect_auto\u001b[0;34m(graph, action_nodes, outcome_nodes, observed_nodes, estimand_type, conditional_node_names, backdoor_adjustment, optimize_backdoor, costs)\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m IdentifiedEstimand(\n\u001b[1;32m 172\u001b[0m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 173\u001b[0m treatment_variable\u001b[38;5;241m=\u001b[39maction_nodes,\n\u001b[1;32m 174\u001b[0m outcome_variable\u001b[38;5;241m=\u001b[39moutcome_nodes,\n\u001b[1;32m 175\u001b[0m no_directed_path\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m 176\u001b[0m )\n\u001b[1;32m 177\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m estimand_type \u001b[38;5;241m==\u001b[39m EstimandType\u001b[38;5;241m.\u001b[39mNONPARAMETRIC_ATE:\n\u001b[0;32m--> 178\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43midentify_ate_effect\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 179\u001b[0m \u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 180\u001b[0m \u001b[43m \u001b[49m\u001b[43maction_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 181\u001b[0m \u001b[43m \u001b[49m\u001b[43moutcome_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 182\u001b[0m \u001b[43m \u001b[49m\u001b[43mobserved_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 183\u001b[0m \u001b[43m \u001b[49m\u001b[43mbackdoor_adjustment\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 184\u001b[0m \u001b[43m \u001b[49m\u001b[43moptimize_backdoor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 185\u001b[0m \u001b[43m \u001b[49m\u001b[43mestimand_type\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 186\u001b[0m \u001b[43m \u001b[49m\u001b[43mcosts\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 187\u001b[0m \u001b[43m \u001b[49m\u001b[43mconditional_node_names\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 188\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 189\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m estimand_type \u001b[38;5;241m==\u001b[39m EstimandType\u001b[38;5;241m.\u001b[39mNONPARAMETRIC_NDE:\n\u001b[1;32m 190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m identify_nde_effect(\n\u001b[1;32m 191\u001b[0m graph, action_nodes, outcome_nodes, observed_nodes, backdoor_adjustment, estimand_type\n\u001b[1;32m 192\u001b[0m )\n", - "File \u001b[0;32m~/home/dowhy/dowhy/causal_identifier/auto_identifier.py:231\u001b[0m, in \u001b[0;36midentify_ate_effect\u001b[0;34m(graph, action_nodes, outcome_nodes, observed_nodes, backdoor_adjustment, optimize_backdoor, estimand_type, costs, conditional_node_names)\u001b[0m\n\u001b[1;32m 228\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m backdoor_adjustment \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m EFFICIENT_METHODS:\n\u001b[1;32m 229\u001b[0m \u001b[38;5;66;03m# First, checking if there are any valid backdoor adjustment sets\u001b[39;00m\n\u001b[1;32m 230\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m optimize_backdoor \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m:\n\u001b[0;32m--> 231\u001b[0m backdoor_sets \u001b[38;5;241m=\u001b[39m \u001b[43midentify_backdoor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maction_nodes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutcome_nodes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mobserved_nodes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbackdoor_adjustment\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 232\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 233\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mdowhy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcausal_identifier\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mbackdoor\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Backdoor\n", - "File \u001b[0;32m~/home/dowhy/dowhy/causal_identifier/auto_identifier.py:499\u001b[0m, in \u001b[0;36midentify_backdoor\u001b[0;34m(graph, action_nodes, outcome_nodes, observed_nodes, backdoor_adjustment, include_unobserved, dseparation_algo, direct_effect)\u001b[0m\n\u001b[1;32m 497\u001b[0m backdoor_paths \u001b[38;5;241m=\u001b[39m get_backdoor_paths(graph, action_nodes, outcome_nodes)\n\u001b[1;32m 498\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m dseparation_algo \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdefault\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m--> 499\u001b[0m bdoor_graph \u001b[38;5;241m=\u001b[39m \u001b[43mdo_surgery\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 500\u001b[0m \u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 501\u001b[0m \u001b[43m \u001b[49m\u001b[43maction_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 502\u001b[0m \u001b[43m \u001b[49m\u001b[43mtarget_node_names\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutcome_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 503\u001b[0m \u001b[43m \u001b[49m\u001b[43mremove_outgoing_edges\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 504\u001b[0m \u001b[43m \u001b[49m\u001b[43mremove_only_direct_edges_to_target\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdirect_effect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 505\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 506\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 507\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124md-separation algorithm \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdseparation_algo\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m is not supported\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "File \u001b[0;32m~/home/dowhy/dowhy/graph.py:136\u001b[0m, in \u001b[0;36mdo_surgery\u001b[0;34m(graph, node_names, remove_outgoing_edges, remove_incoming_edges, target_node_names, remove_only_direct_edges_to_target)\u001b[0m\n\u001b[1;32m 134\u001b[0m new_graph\u001b[38;5;241m.\u001b[39mremove_edges_from([(node_name, v) \u001b[38;5;28;01mfor\u001b[39;00m v \u001b[38;5;129;01min\u001b[39;00m target_node_names])\n\u001b[1;32m 135\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 136\u001b[0m children \u001b[38;5;241m=\u001b[39m \u001b[43mnew_graph\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msuccessors\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnode_name\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 137\u001b[0m edges_bunch \u001b[38;5;241m=\u001b[39m [(node_name, child) \u001b[38;5;28;01mfor\u001b[39;00m child \u001b[38;5;129;01min\u001b[39;00m children]\n\u001b[1;32m 138\u001b[0m new_graph\u001b[38;5;241m.\u001b[39mremove_edges_from(edges_bunch)\n", - "File \u001b[0;32m~/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/networkx/classes/digraph.py:910\u001b[0m, in \u001b[0;36mDiGraph.successors\u001b[0;34m(self, n)\u001b[0m\n\u001b[1;32m 908\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28miter\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_succ[n])\n\u001b[1;32m 909\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[0;32m--> 910\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m NetworkXError(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe node \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mn\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m is not in the digraph.\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merr\u001b[39;00m\n", - "\u001b[0;31mNetworkXError\u001b[0m: The node V5_lag1 is not in the digraph." + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/scipy/stats/_axis_nan_policy.py:531: UserWarning: kurtosistest only valid for n>=20 ... continuing anyway, n=14\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimator.py:266: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", + " by_effect_mods = data.groupby(effect_modifier_names)\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n" ] } ], @@ -303,9 +456,9 @@ "\n", "model = CausalModel(\n", " data=time_shifted_df,\n", - " treatment=treatment_columns,\n", - " outcome=target_node,\n", - " graph=graph\n", + " treatment='V5_-1',\n", + " outcome=target_node+\"_0\",\n", + " graph = unrolled_graph\n", ")\n", "\n", "identified_estimand = model.identify_effect()\n", @@ -314,8 +467,6 @@ " method_name=\"backdoor.linear_regression\",\n", " test_significance=True)\n", "\n", - "common_causes = model._common_causes\n", - "# estimate v5t effect on v6t\n", "\n", "print(estimate)" ] diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 3d2e75d49..d5cb36dc7 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -1,4 +1,5 @@ from typing import List, Optional, Tuple +from collections import deque import networkx as nx import pandas as pd @@ -21,7 +22,7 @@ def find_ancestors(graph: nx.DiGraph, node: str) -> List[str]: ancestors.append(n) return ancestors - +# find parents and ancestors with accumulated time lags def find_lagged_parents(graph: nx.DiGraph, node: str) -> Tuple[List[str], List[int]]: """ Given a graph and a node, this function returns the parent nodes of the node and the time lags associated with the edges between the parent nodes and the node. @@ -42,6 +43,53 @@ def find_lagged_parents(graph: nx.DiGraph, node: str) -> Tuple[List[str], List[i time_lags.append(edge_data["time_lag"]) return parent_nodes, time_lags +def reverse_bfs_with_accumulated_lags(graph: nx.DiGraph, start_node: str) -> nx.DiGraph: + """ + Perform a reverse BFS starting from the node and proceed to parents level-wise, + adding edges from the ancestor to the start_node with the accumulated time lag if it does not already exist. + + :param graph: The directed graph object. + :type graph: networkx.DiGraph + :param start_node: The node from which to start the reverse BFS. + :type start_node: string + :return: A new graph with added edges based on accumulated time lags. + :rtype: networkx.DiGraph + """ + new_graph = nx.DiGraph() + queue = deque([(start_node, 0)]) # (current_node, accumulated_time_lag) + visited = set() + + while queue: + current_node, accumulated_time_lag = queue.popleft() + + if (current_node, accumulated_time_lag) in visited: + continue + + visited.add((current_node, accumulated_time_lag)) + + for parent in graph.predecessors(current_node): + edge_data = graph.get_edge_data(parent, current_node) + if "time_lag" in edge_data: + parent_time_lag = edge_data["time_lag"] + if isinstance(parent_time_lag, tuple): + for lag in parent_time_lag: + total_lag = accumulated_time_lag + lag + if not new_graph.has_edge(parent, start_node): + new_graph.add_edge(parent, start_node, time_lag=(total_lag,)) + else: + existing_lags = new_graph[parent][start_node]["time_lag"] + new_graph[parent][start_node]["time_lag"] = existing_lags + (total_lag,) + queue.append((parent, total_lag)) + else: + total_lag = accumulated_time_lag + parent_time_lag + if not new_graph.has_edge(parent, start_node): + new_graph.add_edge(parent, start_node, time_lag=(total_lag,)) + else: + existing_lags = new_graph[parent][start_node]["time_lag"] + new_graph[parent][start_node]["time_lag"] = existing_lags + (total_lag,) + queue.append((parent, total_lag)) + + return new_graph def shift_columns_by_lag( df: pd.DataFrame, @@ -75,7 +123,6 @@ def shift_columns_by_lag( new_df = df.copy() for column, max_lag in zip(columns, lag): - max_lag = int(max_lag) for shift in range(1, max_lag + 1): new_column_name = f"{column}_lag{shift}" new_df[new_column_name] = new_df[column].shift(shift, axis=0, fill_value=0) @@ -84,7 +131,7 @@ def shift_columns_by_lag( relevant_columns = ( [child_node] + columns - + [f"{col}_lag{shift}" for col in columns for shift in range(1, int(lag[columns.index(col)]) + 1)] + + [f"{col}_lag{shift}" for col in columns for shift in range(1, lag[columns.index(col)] + 1)] ) relevant_columns = list(dict.fromkeys(relevant_columns)) # Ensure unique and maintain order new_df = new_df[relevant_columns] @@ -93,3 +140,33 @@ def shift_columns_by_lag( new_df[ancestor] = df[ancestor] return new_df + + +def shift_columns_by_lag_using_unrolled_graph( + df: pd.DataFrame, + unrolled_graph: nx.DiGraph +) -> pd.DataFrame: + """ + Given a dataframe and an unrolled graph, this function shifts the columns in the dataframe by the corresponding time lags mentioned in the node names of the unrolled graph, + creating a new unique column for each shifted version. + + :param df: The dataframe to shift. + :type df: pandas.DataFrame + :param unrolled_graph: The unrolled graph with nodes containing time lags in their names. + :type unrolled_graph: networkx.DiGraph + :return: The dataframe with the columns shifted by the corresponding time lags. + :rtype: pandas.DataFrame + """ + new_df = pd.DataFrame() + for node in unrolled_graph.nodes: + if '_' in node: + base_node, lag_str = node.rsplit('_', 1) + try: + lag = -int(lag_str) + if base_node in df.columns: + new_column_name = f"{base_node}_{-lag}" + new_df[new_column_name] = df[base_node].shift(lag, axis=0, fill_value=0) + except ValueError: + print(f"Warning: Cannot extract lag from node name {node}. Expected format 'baseNode_lag'") + + return new_df \ No newline at end of file diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py index 643441f17..a67c7ece2 100644 --- a/dowhy/utils/timeseries.py +++ b/dowhy/utils/timeseries.py @@ -2,6 +2,46 @@ import numpy as np import pandas as pd +import networkx as nx + +def unroll_graph(graph: nx.DiGraph) -> nx.DiGraph: + """ + Unrolls a graph by creating a new node for every time lag to the original node and adding those edges to a new graph. + + :param graph: The directed graph object. + :type graph: networkx.DiGraph + :return: An unrolled graph. + :rtype: networkx.DiGraph + """ + unrolled_graph = nx.DiGraph() + node_mapping = {} # Maps original node names to their unrolled counterparts + + for node in graph.nodes: + node_mapping[node] = set() # Use a set to avoid duplicate entries + + for node in graph.nodes: + for parent in graph.predecessors(node): + edge_data = graph.get_edge_data(parent, node) + if "time_lag" in edge_data: + time_lags = edge_data["time_lag"] + if not isinstance(time_lags, tuple): + time_lags = (time_lags,) + + for lag in time_lags: + new_node_name = f"{node}_0" + if new_node_name not in node_mapping[node]: + node_mapping[node].add(new_node_name) + unrolled_graph.add_node(new_node_name) + + parent_unrolled_name = f"{parent}_{-lag}" + if parent_unrolled_name not in node_mapping[parent]: + node_mapping[parent].add(parent_unrolled_name) + unrolled_graph.add_node(parent_unrolled_name) + + unrolled_graph.add_edge(parent_unrolled_name, new_node_name) + + return unrolled_graph + def create_graph_from_user() -> nx.DiGraph: """ From 13573990ee87699b9e0c6d568036e93c060e401f Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Wed, 31 Jul 2024 12:25:22 +0000 Subject: [PATCH 51/67] unrolled graph using bfs --- .../effect_inference_timeseries_data.ipynb | 311 ++---------------- dowhy/timeseries/temporal_shift.py | 86 ++++- dowhy/utils/timeseries.py | 25 +- 3 files changed, 118 insertions(+), 304 deletions(-) diff --git a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index f9e048bc7..428ba3b1e 100644 --- a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -11,13 +11,13 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import networkx as nx\n", "import pandas as pd\n", - "from dowhy.utils.timeseries import create_graph_from_csv,create_graph_from_user, unroll_graph\n", + "from dowhy.utils.timeseries import create_graph_from_csv,create_graph_from_user\n", "from dowhy.utils.plotting import plot, pretty_print_graph" ] }, @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -50,20 +50,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from dowhy.utils.timeseries import create_graph_from_dot_format\n", "\n", @@ -85,26 +74,16 @@ "| V2 | V3 | 4 |\n", "| V5 | V6 | 1 |\n", "| V4 | V7 | 4 |\n", + "| V4 | V5 | 2 |\n", "| V7 | V6 | 3 |\n", "| V7 | V6 | 5 |" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Input a csv file with the edges in the graph with the columns: node_1,node_2,time_lag\n", "file_path = \"../datasets/temporal_graph.csv\"\n", @@ -127,27 +106,18 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "from dowhy.timeseries.temporal_shift import find_lagged_parents,shift_columns_by_lag, find_ancestors,reverse_bfs_with_accumulated_lags,shift_columns_by_lag_using_unrolled_graph" + "from dowhy.timeseries.temporal_shift import find_lagged_parents,shift_columns_by_lag, find_ancestors,shift_columns_by_lag_using_unrolled_graph, reverse_bfs_with_accumulated_lags_unroll" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Parents of the target node with respective time lags: ['V5', 'V7'] [(1,), (3, 5)]\n", - "Ancestors of the target node: ['V4']\n" - ] - } - ], + "outputs": [], "source": [ "# the outcome node for which effect estimation has to be done, node:6\n", "target_node = 'V6'\n", @@ -161,174 +131,28 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIIAAAAUCAYAAABBPOWjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAABJ0AAASdAHeZh94AAAEvUlEQVR4nO2aa6gVVRTHf5pQcisFJaWgbmZahKlUYE+L0ugFRkFf1CywJCIS75ci+PsvfAQ9JIweCFkWWCAZvSm4KhY9NUJ6k0qB+dbyRWW3D3tOHs+ZmbvnnBntgz+47Dl7z157rXXX3rP3munT09PDMY7R92grcIz/B/1qF7avBLrr2r6XdE5jB9svAtcBZ0raW7WCti8AvgCmS1p0BMY7ovaVSZ6vbA8GttbXSepTu+5HMyuBFcC2lIEuAqYAXY1Osn0rMB4YA4wGTgJekTS5sEWHK/ul7eXAI7aXStrTjrw8suyz/ShwITACGAzsBzYCy4GFkrZXpM8G4IyM5s2ShtZX9OKrfYCT62mNctMCYYWk2RmDzwF+B55JaXuIEAB7gF+BptWkDeYBnwL3AXNLlNtIln0zgTXAB8AWoAMYB8wG7rI9TtIvFem0G1iQUp81IVJ9JWkfQd/a6t9rIKRiewRwDbBI0v6UW2YSAuAnwsrQnXJPS0j6zPZ3wN2250v6pyzZNXqx72RJB1L6zAEeBB4A7ilbp4RdOROziVZ9VWSzeCfQB3g1Q4FuST9KquoYshQ4HZhQkfxM+9KCIOG1pDy7Ip1apbCvolcEwmw5CHxSUKmy+CgpJwDvVyC/FftuSsqvy1fnP463PZnwj92bjLVK0sGcPoV9FRUItjsIm8Bvj+JO+vOkvKJswbH22e4CTgQGEDaPlxH+MfPL1qmOocCShrr1tu+QtDKjT2FfxT4aTgOOAzbFCi4bSbuBA4SZUTax9nUBAu4nBMF7wERJW/M6tcELwNWEYOgARgHPAZ3Au7ZHp3VqxVexj4ZBSbkzVnBF7ACGVCA3yr7acc32EOASwkqw1vaNktaUrZQkN1StA2bY3gPMIpwCbs7oXshXsStCbRd9QqzgiujPIV3KpJB9kjZLeh2YSAiilyrQKY9nkzJv6S/kq9hA2JKUg3LvqhDbfYGBdbqUSUv2SdoIfAOcl2TujhS1R1FHWmMrvooNhE3J4CNjBVfASMLx7qsKZLdj36lJmbeLL5txSflzRnthX0UFQpIbWAUMtj08Vnhv2F5su8f2tIjba8Y3JaoKymkizz7bI2wPSBmzb5JQOgX4WNLOhva2dLJ9bnKaaazvBBYmP1/O6J7pqyyK5BGWAbcA1xKyh4dhexIwKflZy4FfbHtxcr1NUldDt1og/h0x/kTCrHsjpa2InCyy7LsemGd7NbAe2E7YhI0HhgG/AdMr0Ok2YJbtVYT3Gn8AZwE3EPYy7wCPZfTN81UqRQNhCzAVeDqlfQxwe0PdsOQPgjGNgTCKYODbeQMnM3IS8FZGTj9KTi9k2fchMJxwXBxLePbuBX4gnO+fkrSjAp26CUv8WOBSwn5gF7A6GXdJWhY3wlepRAeCpD9tLwDm2h4raW1D+2ySlxox2B4InA883rispjCVMAuaZkBBOZlk2SdpHXBvEVll6JQki7ISRnlk+iqPtECQbZH+PcKTwAzgYQ6lV1vlcuAv4Im8m2z3J7zUWSZpdatyIinLvjJ1iibPV2nfI9RTHwgbOPS+GlK+R5B0wPYU4CrbHe2kmyW9Sdy5vRN4HljcppwYnUqxr0ydCtJJtq/qv0do4l8+xOrKvQBRugAAAABJRU5ErkJggg==", - "text/latex": [ - "$\\displaystyle \\left[ \\left( 1,\\right), \\ \\left( 3, \\ 5\\right)\\right]$" - ], - "text/plain": [ - "[(1,), (3, 5)]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "time_lags" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "updated_graph = reverse_bfs_with_accumulated_lags(graph, target_node)\n", - "unrolled_graph = unroll_graph(updated_graph)\n", + "unrolled_graph = reverse_bfs_with_accumulated_lags_unroll(graph, target_node)\n", "plot(unrolled_graph)" ] }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'time_lag': (3, 7, 9)}" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "updated_graph.get_edge_data('V4','V6')" - ] - }, - { - "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
V6_0V5_-1V7_-3V7_-5V4_-3V4_-7V4_-9
06000000
17500000
28600000
39770400
49880500
\n", - "
" - ], - "text/plain": [ - " V6_0 V5_-1 V7_-3 V7_-5 V4_-3 V4_-7 V4_-9\n", - "0 6 0 0 0 0 0 0\n", - "1 7 5 0 0 0 0 0\n", - "2 8 6 0 0 0 0 0\n", - "3 9 7 7 0 4 0 0\n", - "4 9 8 8 0 5 0 0" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "time_shifted_df = shift_columns_by_lag_using_unrolled_graph(dataframe, unrolled_graph)\n", "time_shifted_df.head()" @@ -345,20 +169,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['V5_-1', 'V7_-3', 'V7_-5', 'V4_-3', 'V4_-7', 'V4_-9']" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# include all the treatments\n", "treatment_columns = list(time_shifted_df.columns)\n", @@ -368,87 +181,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "*** Causal Estimate ***\n", - "\n", - "## Identified estimand\n", - "Estimand type: EstimandType.NONPARAMETRIC_ATE\n", - "\n", - "### Estimand : 1\n", - "Estimand name: backdoor\n", - "Estimand expression:\n", - " d \n", - "────────(E[V₆ ₀])\n", - "d[V₅ ₋₁] \n", - "Estimand assumption 1, Unconfoundedness: If U→{V5_-1} and U→V6_0 then P(V6_0|V5_-1,,U) = P(V6_0|V5_-1,)\n", - "\n", - "## Realized estimand\n", - "b: V6_0~V5_-1+V5_-1*V4_-3+V5_-1*V7_-5+V5_-1*V4_-9+V5_-1*V7_-3+V5_-1*V4_-7\n", - "Target units: \n", - "\n", - "## Estimate\n", - "Mean value: 0.11805104580947834\n", - "p-value: [0.18613988]\n", - "### Conditional Estimates\n", - "__categorical__V4_-3 __categorical__V7_-5 __categorical__V4_-9 __categorical__V7_-3 __categorical__V4_-7\n", - "(-0.001, 0.6] (-0.001, 5.4] (-0.001, 5.4] (-0.001, 0.6] (-0.001, 1.8] 0.489469\n", - "(0.6, 4.2] (-0.001, 5.4] (-0.001, 5.4] (5.4, 7.8] (-0.001, 1.8] 0.284098\n", - " (5.4, 7.8] (-0.001, 5.4] (7.8, 9.0] (5.4, 7.0] 0.230999\n", - " (9.0, 10.0] (-0.001, 5.4] (0.6, 5.4] (1.8, 5.4] 0.471972\n", - "(4.2, 5.8] (-0.001, 5.4] (-0.001, 5.4] (7.8, 9.0] (-0.001, 1.8] 0.205896\n", - " (7.8, 9.0] (5.4, 7.0] (0.6, 5.4] (-0.001, 1.8] -0.228553\n", - "(5.8, 6.4] (5.4, 7.8] (-0.001, 5.4] (7.8, 9.0] (-0.001, 1.8] 0.250684\n", - " (7.8, 9.0] (5.4, 7.0] (0.6, 5.4] (1.8, 5.4] -0.322592\n", - " (7.8, 9.0] (5.4, 7.0] -0.324498\n", - "(6.4, 7.0] (-0.001, 5.4] (-0.001, 5.4] (7.8, 9.0] (5.4, 7.0] -0.467333\n", - " (7.8, 9.0] (-0.001, 5.4] (5.4, 7.8] (1.8, 5.4] -0.106417\n", - " (9.0, 10.0] (-0.001, 1.8] 0.190052\n", - "dtype: float64\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/scipy/stats/_axis_nan_policy.py:531: UserWarning: kurtosistest only valid for n>=20 ... continuing anyway, n=14\n", - " res = hypotest_fun_out(*samples, **kwds)\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimator.py:266: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", - " by_effect_mods = data.groupby(effect_modifier_names)\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n" - ] - } - ], + "outputs": [], "source": [ "# perform causal effect estimation on this new dataset\n", "import dowhy\n", diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index d5cb36dc7..6124d8214 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -74,23 +74,93 @@ def reverse_bfs_with_accumulated_lags(graph: nx.DiGraph, start_node: str) -> nx. if isinstance(parent_time_lag, tuple): for lag in parent_time_lag: total_lag = accumulated_time_lag + lag - if not new_graph.has_edge(parent, start_node): - new_graph.add_edge(parent, start_node, time_lag=(total_lag,)) + if not new_graph.has_edge(parent, current_node): + new_graph.add_edge(parent, current_node, time_lag=(total_lag,)) else: - existing_lags = new_graph[parent][start_node]["time_lag"] - new_graph[parent][start_node]["time_lag"] = existing_lags + (total_lag,) + existing_lags = new_graph[parent][current_node]["time_lag"] + new_graph[parent][current_node]["time_lag"] = existing_lags + (total_lag,) queue.append((parent, total_lag)) else: total_lag = accumulated_time_lag + parent_time_lag - if not new_graph.has_edge(parent, start_node): - new_graph.add_edge(parent, start_node, time_lag=(total_lag,)) + if not new_graph.has_edge(parent, current_node): + new_graph.add_edge(parent, current_node, time_lag=(total_lag,)) else: - existing_lags = new_graph[parent][start_node]["time_lag"] - new_graph[parent][start_node]["time_lag"] = existing_lags + (total_lag,) + existing_lags = new_graph[parent][current_node]["time_lag"] + new_graph[parent][current_node]["time_lag"] = existing_lags + (total_lag,) queue.append((parent, total_lag)) return new_graph + +def reverse_bfs_with_accumulated_lags_unroll(graph: nx.DiGraph, start_node: str) -> nx.DiGraph: + """ + Perform a reverse BFS starting from the node and proceed to parents level-wise, + adding edges from the ancestor to the current node with the accumulated time lag if it does not already exist. + Additionally, create lagged nodes for each time lag encountered. + + :param graph: The directed graph object. + :type graph: networkx.DiGraph + :param start_node: The node from which to start the reverse BFS. + :type start_node: string + :return: A new graph with added edges based on accumulated time lags and lagged nodes. + :rtype: networkx.DiGraph + """ + new_graph = nx.DiGraph() + queue = deque([start_node]) + visited = set() + lagged_node_mapping = {} # Maps original nodes to their corresponding lagged nodes + + while queue: + current_node = queue.popleft() + + if current_node in visited: + continue + + # visited.add(current_node) + + for parent in graph.predecessors(current_node): + edge_data = graph.get_edge_data(parent, current_node) + if "time_lag" in edge_data: + parent_time_lag = edge_data["time_lag"] + + # Ensure parent_time_lag is in tuple form + if not isinstance(parent_time_lag, tuple): + parent_time_lag = (parent_time_lag,) + + for lag in parent_time_lag: + # Find or create the lagged node for the current node + if current_node in lagged_node_mapping: + lagged_nodes = lagged_node_mapping[current_node] + else: + lagged_nodes = set() + lagged_nodes.add(f"{current_node}_0") + new_graph.add_node(f"{current_node}_0") + lagged_node_mapping[current_node] = lagged_nodes + + # For each lagged node, create new time-lagged parent nodes and add edges + new_lagged_nodes = set() + for lagged_node in lagged_nodes: + total_lag = - int(lagged_node.split('_')[-1]) + lag + new_lagged_parent_node = f"{parent}_{-total_lag}" + new_lagged_nodes.add(new_lagged_parent_node) + + if not new_graph.has_node(new_lagged_parent_node): + new_graph.add_node(new_lagged_parent_node) + + new_graph.add_edge(new_lagged_parent_node, lagged_node) + + # Add the parent to the queue for further exploration + queue.append(parent) + + # lagged_node_mapping[parent] = new_lagged_nodes + # append the lagged nodes + if parent in lagged_node_mapping: + lagged_node_mapping[parent] = lagged_node_mapping[parent].union(new_lagged_nodes) + else: + lagged_node_mapping[parent] = new_lagged_nodes + + return new_graph + def shift_columns_by_lag( df: pd.DataFrame, columns: List[str], diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py index a67c7ece2..2d0d725e7 100644 --- a/dowhy/utils/timeseries.py +++ b/dowhy/utils/timeseries.py @@ -26,22 +26,31 @@ def unroll_graph(graph: nx.DiGraph) -> nx.DiGraph: time_lags = edge_data["time_lag"] if not isinstance(time_lags, tuple): time_lags = (time_lags,) - - for lag in time_lags: + + # Create a new node for the current child node if its mapping set is empty + if not node_mapping[node]: new_node_name = f"{node}_0" - if new_node_name not in node_mapping[node]: - node_mapping[node].add(new_node_name) - unrolled_graph.add_node(new_node_name) - + node_mapping[node].add(new_node_name) + unrolled_graph.add_node(new_node_name) + else: + # Use the existing child node for edge creation + new_node_name = f"{node}_0" # This will represent the current node's base name + + # Add edges from parent to all existing time-lagged children + for lag in time_lags: parent_unrolled_name = f"{parent}_{-lag}" if parent_unrolled_name not in node_mapping[parent]: node_mapping[parent].add(parent_unrolled_name) unrolled_graph.add_node(parent_unrolled_name) - + + # Add edge from the parent to the current child node unrolled_graph.add_edge(parent_unrolled_name, new_node_name) - return unrolled_graph + # Add edges from parent to all existing time-lagged children of this node + for existing_child in node_mapping[node]: + unrolled_graph.add_edge(parent_unrolled_name, existing_child) + return unrolled_graph def create_graph_from_user() -> nx.DiGraph: """ From 9cefd8797d75cc9d7552ccc6635131a1dc5560d0 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Wed, 31 Jul 2024 12:32:12 +0000 Subject: [PATCH 52/67] cleanup of functions --- .../effect_inference_timeseries_data.ipynb | 32 ++--------- dowhy/timeseries/temporal_shift.py | 57 +------------------ dowhy/utils/timeseries.py | 47 --------------- 3 files changed, 6 insertions(+), 130 deletions(-) diff --git a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index 428ba3b1e..2849a44fe 100644 --- a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -110,7 +110,7 @@ "metadata": {}, "outputs": [], "source": [ - "from dowhy.timeseries.temporal_shift import find_lagged_parents,shift_columns_by_lag, find_ancestors,shift_columns_by_lag_using_unrolled_graph, reverse_bfs_with_accumulated_lags_unroll" + "from dowhy.timeseries.temporal_shift import shift_columns_by_lag_using_unrolled_graph, add_lagged_edges" ] }, { @@ -121,30 +121,7 @@ "source": [ "# the outcome node for which effect estimation has to be done, node:6\n", "target_node = 'V6'\n", - "\n", - "# find the action nodes of the given target node with respective lag times\n", - "parents, time_lags = find_lagged_parents(graph, target_node)\n", - "ancestors = find_ancestors(graph, target_node)\n", - "print (\"Parents of the target node with respective time lags: \", parents, time_lags)\n", - "print (\"Ancestors of the target node: \", ancestors)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "time_lags" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "unrolled_graph = reverse_bfs_with_accumulated_lags_unroll(graph, target_node)\n", + "unrolled_graph = add_lagged_edges(graph, target_node)\n", "plot(unrolled_graph)" ] }, @@ -173,9 +150,10 @@ "metadata": {}, "outputs": [], "source": [ + "target_node = 'V6_0'\n", "# include all the treatments\n", "treatment_columns = list(time_shifted_df.columns)\n", - "treatment_columns.remove(target_node+\"_0\")\n", + "treatment_columns.remove(target_node)\n", "treatment_columns" ] }, @@ -192,7 +170,7 @@ "model = CausalModel(\n", " data=time_shifted_df,\n", " treatment='V5_-1',\n", - " outcome=target_node+\"_0\",\n", + " outcome=target_node,\n", " graph = unrolled_graph\n", ")\n", "\n", diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 6124d8214..f0125dc7e 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -43,56 +43,8 @@ def find_lagged_parents(graph: nx.DiGraph, node: str) -> Tuple[List[str], List[i time_lags.append(edge_data["time_lag"]) return parent_nodes, time_lags -def reverse_bfs_with_accumulated_lags(graph: nx.DiGraph, start_node: str) -> nx.DiGraph: - """ - Perform a reverse BFS starting from the node and proceed to parents level-wise, - adding edges from the ancestor to the start_node with the accumulated time lag if it does not already exist. - :param graph: The directed graph object. - :type graph: networkx.DiGraph - :param start_node: The node from which to start the reverse BFS. - :type start_node: string - :return: A new graph with added edges based on accumulated time lags. - :rtype: networkx.DiGraph - """ - new_graph = nx.DiGraph() - queue = deque([(start_node, 0)]) # (current_node, accumulated_time_lag) - visited = set() - - while queue: - current_node, accumulated_time_lag = queue.popleft() - - if (current_node, accumulated_time_lag) in visited: - continue - - visited.add((current_node, accumulated_time_lag)) - - for parent in graph.predecessors(current_node): - edge_data = graph.get_edge_data(parent, current_node) - if "time_lag" in edge_data: - parent_time_lag = edge_data["time_lag"] - if isinstance(parent_time_lag, tuple): - for lag in parent_time_lag: - total_lag = accumulated_time_lag + lag - if not new_graph.has_edge(parent, current_node): - new_graph.add_edge(parent, current_node, time_lag=(total_lag,)) - else: - existing_lags = new_graph[parent][current_node]["time_lag"] - new_graph[parent][current_node]["time_lag"] = existing_lags + (total_lag,) - queue.append((parent, total_lag)) - else: - total_lag = accumulated_time_lag + parent_time_lag - if not new_graph.has_edge(parent, current_node): - new_graph.add_edge(parent, current_node, time_lag=(total_lag,)) - else: - existing_lags = new_graph[parent][current_node]["time_lag"] - new_graph[parent][current_node]["time_lag"] = existing_lags + (total_lag,) - queue.append((parent, total_lag)) - - return new_graph - - -def reverse_bfs_with_accumulated_lags_unroll(graph: nx.DiGraph, start_node: str) -> nx.DiGraph: +def add_lagged_edges(graph: nx.DiGraph, start_node: str) -> nx.DiGraph: """ Perform a reverse BFS starting from the node and proceed to parents level-wise, adding edges from the ancestor to the current node with the accumulated time lag if it does not already exist. @@ -107,17 +59,11 @@ def reverse_bfs_with_accumulated_lags_unroll(graph: nx.DiGraph, start_node: str) """ new_graph = nx.DiGraph() queue = deque([start_node]) - visited = set() lagged_node_mapping = {} # Maps original nodes to their corresponding lagged nodes while queue: current_node = queue.popleft() - if current_node in visited: - continue - - # visited.add(current_node) - for parent in graph.predecessors(current_node): edge_data = graph.get_edge_data(parent, current_node) if "time_lag" in edge_data: @@ -152,7 +98,6 @@ def reverse_bfs_with_accumulated_lags_unroll(graph: nx.DiGraph, start_node: str) # Add the parent to the queue for further exploration queue.append(parent) - # lagged_node_mapping[parent] = new_lagged_nodes # append the lagged nodes if parent in lagged_node_mapping: lagged_node_mapping[parent] = lagged_node_mapping[parent].union(new_lagged_nodes) diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py index 2d0d725e7..a5bcde1ba 100644 --- a/dowhy/utils/timeseries.py +++ b/dowhy/utils/timeseries.py @@ -4,53 +4,6 @@ import networkx as nx -def unroll_graph(graph: nx.DiGraph) -> nx.DiGraph: - """ - Unrolls a graph by creating a new node for every time lag to the original node and adding those edges to a new graph. - - :param graph: The directed graph object. - :type graph: networkx.DiGraph - :return: An unrolled graph. - :rtype: networkx.DiGraph - """ - unrolled_graph = nx.DiGraph() - node_mapping = {} # Maps original node names to their unrolled counterparts - - for node in graph.nodes: - node_mapping[node] = set() # Use a set to avoid duplicate entries - - for node in graph.nodes: - for parent in graph.predecessors(node): - edge_data = graph.get_edge_data(parent, node) - if "time_lag" in edge_data: - time_lags = edge_data["time_lag"] - if not isinstance(time_lags, tuple): - time_lags = (time_lags,) - - # Create a new node for the current child node if its mapping set is empty - if not node_mapping[node]: - new_node_name = f"{node}_0" - node_mapping[node].add(new_node_name) - unrolled_graph.add_node(new_node_name) - else: - # Use the existing child node for edge creation - new_node_name = f"{node}_0" # This will represent the current node's base name - - # Add edges from parent to all existing time-lagged children - for lag in time_lags: - parent_unrolled_name = f"{parent}_{-lag}" - if parent_unrolled_name not in node_mapping[parent]: - node_mapping[parent].add(parent_unrolled_name) - unrolled_graph.add_node(parent_unrolled_name) - - # Add edge from the parent to the current child node - unrolled_graph.add_edge(parent_unrolled_name, new_node_name) - - # Add edges from parent to all existing time-lagged children of this node - for existing_child in node_mapping[node]: - unrolled_graph.add_edge(parent_unrolled_name, existing_child) - - return unrolled_graph def create_graph_from_user() -> nx.DiGraph: """ From ed5962ed935f2d22eb3e3ed74c8cd30b6eec3f9e Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 1 Aug 2024 08:44:22 +0000 Subject: [PATCH 53/67] removed find parents and ancestors --- dowhy/timeseries/temporal_shift.py | 89 ------------------------------ 1 file changed, 89 deletions(-) diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index f0125dc7e..af1db990f 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -5,45 +5,6 @@ import pandas as pd -def find_ancestors(graph: nx.DiGraph, node: str) -> List[str]: - """ - Given a graph and a node, this function returns the ancestor nodes of the node that are not parents. - - :param graph: The graph object. - :type graph: networkx.Graph - :param node: The node for which we want to find the ancestor nodes. - :type node: string - :return: A list of ancestor nodes of the node. - :rtype: list - """ - ancestors = [] - for n in nx.ancestors(graph, node): - if n not in graph.predecessors(node): - ancestors.append(n) - return ancestors - -# find parents and ancestors with accumulated time lags -def find_lagged_parents(graph: nx.DiGraph, node: str) -> Tuple[List[str], List[int]]: - """ - Given a graph and a node, this function returns the parent nodes of the node and the time lags associated with the edges between the parent nodes and the node. - - :param graph: The graph object. - :type graph: networkx.Graph - :param node: The node for which we want to find the parent nodes. - :type node: string - :return: A tuple containing a list of parent nodes of the node and a list of time lags associated with the edges between the parent nodes and the node. - :rtype: tuple (list, list) - """ - parent_nodes = [] - time_lags = [] - for n in graph.predecessors(node): - edge_data = graph.get_edge_data(n, node) - if "time_lag" in edge_data: - parent_nodes.append(n) - time_lags.append(edge_data["time_lag"]) - return parent_nodes, time_lags - - def add_lagged_edges(graph: nx.DiGraph, start_node: str) -> nx.DiGraph: """ Perform a reverse BFS starting from the node and proceed to parents level-wise, @@ -106,56 +67,6 @@ def add_lagged_edges(graph: nx.DiGraph, start_node: str) -> nx.DiGraph: return new_graph -def shift_columns_by_lag( - df: pd.DataFrame, - columns: List[str], - lag: List[int], - ancestors: List[str], - filter: bool, - child_node: Optional[str] = None, -) -> pd.DataFrame: - """ - Given a dataframe, a list of columns, and a list of time lags, this function shifts the columns in the dataframe by the corresponding time lags, creating a new unique column for each shifted version. - Optionally, it can filter the dataframe to keep only the columns of the child node, the parent nodes, and their shifted versions. - - :param df: The dataframe to shift. - :type df: pandas.DataFrame - :param columns: A list of columns to shift. - :type columns: list - :param lag: A list of time lags to shift the columns by. - :type lag: list - :param ancestors: A list of ancestor nodes of the child node. - :type ancestors: list - :param filter: A boolean indicating whether to filter the dataframe to keep only relevant columns. - :type filter: bool - :param child_node: The child node to keep when filtering. - :type child_node: int, optional - :return: The dataframe with the columns shifted by the corresponding time lags and optionally filtered. - :rtype: pandas.DataFrame - """ - if len(columns) != len(lag): - raise ValueError("The size of 'columns' and 'lag' lists must be the same.") - - new_df = df.copy() - for column, max_lag in zip(columns, lag): - for shift in range(1, max_lag + 1): - new_column_name = f"{column}_lag{shift}" - new_df[new_column_name] = new_df[column].shift(shift, axis=0, fill_value=0) - - if filter and child_node is not None: - relevant_columns = ( - [child_node] - + columns - + [f"{col}_lag{shift}" for col in columns for shift in range(1, lag[columns.index(col)] + 1)] - ) - relevant_columns = list(dict.fromkeys(relevant_columns)) # Ensure unique and maintain order - new_df = new_df[relevant_columns] - - for ancestor in ancestors: - new_df[ancestor] = df[ancestor] - - return new_df - def shift_columns_by_lag_using_unrolled_graph( df: pd.DataFrame, From af92dcea5b7b1464a93d3decf2779e1909cebb5d Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 1 Aug 2024 10:15:23 +0000 Subject: [PATCH 54/67] updated graph creation functions --- dowhy/utils/timeseries.py | 97 +++++++++++++++++++++++++-------------- 1 file changed, 62 insertions(+), 35 deletions(-) diff --git a/dowhy/utils/timeseries.py b/dowhy/utils/timeseries.py index a5bcde1ba..a815736d2 100644 --- a/dowhy/utils/timeseries.py +++ b/dowhy/utils/timeseries.py @@ -2,14 +2,13 @@ import numpy as np import pandas as pd -import networkx as nx - def create_graph_from_user() -> nx.DiGraph: """ Creates a directed graph based on user input from the console. - The time_lag parameter of the networkx graph represents the maximal causal lag of an edge between any 2 nodes in the graph. + The time_lag parameter of the networkx graph represents the exact causal lag of an edge between any 2 nodes in the graph. + Each edge can contain multiple time lags, therefore each combination of (node1,node2,time_lag) must be input individually by the user. The user is prompted to enter edges one by one in the format 'node1 node2 time_lag', where 'node1' and 'node2' are the nodes connected by the edge, and 'time_lag' is a numerical @@ -23,14 +22,11 @@ def create_graph_from_user() -> nx.DiGraph: Enter an edge: B C 2 Enter an edge: done """ - # Initialize an empty directed graph graph = nx.DiGraph() - # Instructions for the user print("Enter the graph as a list of edges with time lags. Enter 'done' when you are finished.") print("Each edge should be entered in the format 'node1 node2 time_lag'. For example: 'A B 4'") - # Loop to receive user input while True: edge = input("Enter an edge: ") if edge.lower() == "done": @@ -45,7 +41,18 @@ def create_graph_from_user() -> nx.DiGraph: except ValueError: print("Invalid weight. Please enter a numerical value for the time_lag.") continue - graph.add_edge(node1, node2, time_lag=time_lag) + + # Check if the edge already exists + if graph.has_edge(node1, node2): + # If the edge exists, append the time_lag to the existing tuple + current_time_lag = graph[node1][node2]["time_lag"] + if isinstance(current_time_lag, tuple): + graph[node1][node2]["time_lag"] = current_time_lag + (time_lag,) + else: + graph[node1][node2]["time_lag"] = (current_time_lag, time_lag) + else: + # If the edge does not exist, create a new edge with a tuple containing the time_lag + graph.add_edge(node1, node2, time_lag=(time_lag,)) return graph @@ -54,7 +61,8 @@ def create_graph_from_csv(file_path: str) -> nx.DiGraph: """ Creates a directed graph from a CSV file. - The time_lag parameter of the networkx graph represents the maximal causal lag of an edge between any 2 nodes in the graph. + The time_lag parameter of the networkx graph represents the exact causal lag of an edge between any 2 nodes in the graph. + Each edge can contain multiple time lags, therefore each combination of (node1,node2,time_lag) must be input individually in the CSV file. The CSV file should have at least three columns: 'node1', 'node2', and 'time_lag'. Each row represents an edge from 'node1' to 'node2' with a 'time_lag' attribute. @@ -112,7 +120,8 @@ def create_graph_from_dot_format(file_path: str) -> nx.DiGraph: """ Creates a directed graph from a DOT file and ensures it is a DiGraph. - The time_lag parameter of the networkx graph represents the maximal causal lag of an edge between any 2 nodes in the graph. + The time_lag parameter of the networkx graph represents the exact causal lag of an edge between any 2 nodes in the graph. + Each edge can contain multiple valid time lags. The DOT file should contain a graph in DOT format. @@ -131,18 +140,21 @@ def create_graph_from_dot_format(file_path: str) -> nx.DiGraph: for u, v, data in multi_graph.edges(data=True): if "label" in data: try: - time_lag = int(data["label"]) + # Convert the label to a tuple of time lags + time_lag_tuple = tuple(map(int, data["label"].strip("()").split(","))) - # Handle multiple edges between the same nodes if graph.has_edge(u, v): existing_data = graph.get_edge_data(u, v) if "time_lag" in existing_data: - # Use maximum time_lag if multiple edges exist - existing_data["time_lag"] = max(existing_data["time_lag"], time_lag) + # Merge the existing time lags with the new ones + existing_time_lags = existing_data["time_lag"] + new_time_lags = existing_time_lags + time_lag_tuple + # Remove duplicates by converting to a set and back to a tuple + graph[u][v]["time_lag"] = tuple(set(new_time_lags)) else: - existing_data["time_lag"] = time_lag + graph[u][v]["time_lag"] = time_lag_tuple else: - graph.add_edge(u, v, time_lag=time_lag) + graph.add_edge(u, v, time_lag=time_lag_tuple) except ValueError: print(f"Invalid weight for the edge between {u} and {v}.") @@ -155,7 +167,8 @@ def create_graph_from_networkx_array(array: np.ndarray, var_names: list) -> nx.D """ Create a NetworkX directed graph from a numpy array with time lag information. - The time_lag parameter of the networkx graph represents the maximal causal lag of an edge between any 2 nodes in the graph. + The time_lag parameter of the networkx graph represents the exact causal lag of an edge between any 2 nodes in the graph. + Each edge can contain multiple valid time lags. The resulting graph will be a directed graph with edge attributes indicating the type of link based on the array values. @@ -168,6 +181,7 @@ def create_graph_from_networkx_array(array: np.ndarray, var_names: list) -> nx.D :rtype: nx.DiGraph """ n = array.shape[0] # Number of variables + assert n == array.shape[1], "The array must be square." tau = array.shape[2] # Number of time lags # Initialize a directed graph @@ -182,25 +196,38 @@ def create_graph_from_networkx_array(array: np.ndarray, var_names: list) -> nx.D if i == j: continue # Skip self-loops - # Check for contemporaneous links (tau = 0) - if array[i, j, 0] == "-->": - graph.add_edge(var_names[i], var_names[j], type="contemporaneous", direction="forward") - elif array[i, j, 0] == "<--": - graph.add_edge(var_names[j], var_names[i], type="contemporaneous", direction="backward") - elif array[i, j, 0] == "o-o": - # raise error - graph.add_edge(var_names[i], var_names[j], type="adjacency", style="circle") - graph.add_edge(var_names[j], var_names[i], type="adjacency", style="circle") - elif array[i, j, 0] == "x-x": - # raise dag error / not supported / conflicting - graph.add_edge(var_names[i], var_names[j], type="conflicting", style="cross") - graph.add_edge(var_names[j], var_names[i], type="conflicting", style="cross") - - # Check for lagged links (tau > 0) - for t in range(1, tau): + for t in range(tau): + # Check for directed links if array[i, j, t] == "-->": - graph.add_edge(var_names[i], var_names[j], time_lag=t) - elif array[j, i, t] == "-->": - graph.add_edge(var_names[j], var_names[i], time_lag=t) + if graph.has_edge(var_names[i], var_names[j]): + # Append the time lag to the existing tuple + current_time_lag = graph[var_names[i]][var_names[j]].get("time_lag", ()) + graph[var_names[i]][var_names[j]]["time_lag"] = current_time_lag + (t,) + else: + # Create a new edge with a tuple containing the time lag + graph.add_edge(var_names[i], var_names[j], time_lag=(t,)) + + elif array[i, j, t] == "<--": + if graph.has_edge(var_names[j], var_names[i]): + # Append the time lag to the existing tuple + current_time_lag = graph[var_names[j]][var_names[i]].get("time_lag", ()) + graph[var_names[j]][var_names[i]]["time_lag"] = current_time_lag + (t,) + else: + # Create a new edge with a tuple containing the time lag + graph.add_edge(var_names[j], var_names[i], time_lag=(t,)) + + elif array[i, j, t] == "o-o": + raise ValueError( + "Unsupported link type 'o-o' found between {} and {} at lag {}.".format( + var_names[i], var_names[j], t + ) + ) + + elif array[i, j, t] == "x-x": + raise ValueError( + "Unsupported link type 'x-x' found between {} and {} at lag {}.".format( + var_names[i], var_names[j], t + ) + ) return graph From e4dbc3b974a16104e488c03de4fa08a6996e71cd Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 1 Aug 2024 10:28:47 +0000 Subject: [PATCH 55/67] multiple time lags : dot file --- .../example_notebooks/datasets/temporal_graph.dot | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/docs/source/example_notebooks/datasets/temporal_graph.dot b/docs/source/example_notebooks/datasets/temporal_graph.dot index a7fe9272e..da6b6ed67 100644 --- a/docs/source/example_notebooks/datasets/temporal_graph.dot +++ b/docs/source/example_notebooks/datasets/temporal_graph.dot @@ -1,7 +1,8 @@ digraph G { - V1 -> V2 [label=3]; - V2 -> V3 [label=4]; - V5 -> V6 [label=1]; - V4 -> V7 [label=4]; - V7 -> V6 [label=3]; + V1 -> V2 [label="(3)"]; + V2 -> V3 [label="(4)"]; + V5 -> V6 [label="(1)"]; + V4 -> V7 [label="(4)"]; + V4 -> V5 [label="(2)"]; + V7 -> V6 [label="(3, 5)"]; } \ No newline at end of file From 74a88b7e39f24b6d58d6d79ae02c6ee3fc45dd92 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 1 Aug 2024 10:29:24 +0000 Subject: [PATCH 56/67] import update --- .../timeseries/effect_inference_timeseries_data.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index 2849a44fe..5d3dc959c 100644 --- a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -200,14 +200,14 @@ "outputs": [], "source": [ "import tigramite\n", - "from tigramite import data_processing\n", + "import tigramite.data_processing as pp\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "\n", "dataframe = dataframe.astype(float)\n", "var_names = dataframe.columns\n", "# convert the dataframe values to float\n", - "dataframe = tigramite.data_processing.DataFrame(dataframe.values, var_names=var_names)" + "dataframe = pp.DataFrame(dataframe.values, var_names=var_names)" ] }, { From d0bfc643f067d4cef51ff1e7b0fc1e66c67ecd93 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 1 Aug 2024 10:41:28 +0000 Subject: [PATCH 57/67] tests for causal graph creation --- .../test_temporal_causal_graph_creation.py | 241 +++++++++++++++--- 1 file changed, 202 insertions(+), 39 deletions(-) diff --git a/tests/timeseries/test_temporal_causal_graph_creation.py b/tests/timeseries/test_temporal_causal_graph_creation.py index f3cfc1373..40a82b56b 100644 --- a/tests/timeseries/test_temporal_causal_graph_creation.py +++ b/tests/timeseries/test_temporal_causal_graph_creation.py @@ -1,64 +1,227 @@ import unittest +from io import StringIO + import networkx as nx -import pandas as pd import numpy as np -from io import StringIO -from dowhy.utils.timeseries import create_graph_from_user, create_graph_from_csv, create_graph_from_dot_format, create_graph_from_array +import pandas as pd + +from dowhy.utils.timeseries import create_graph_from_csv, create_graph_from_dot_format, create_graph_from_networkx_array -class TestGraphFunctions(unittest.TestCase): - def test_create_graph_from_csv(self): +class TestCreateGraphFromCSV(unittest.TestCase): + + def test_basic_functionality(self): csv_content = """node1,node2,time_lag A,B,5 B,C,2 A,C,7""" df = pd.read_csv(StringIO(csv_content)) df.to_csv("test.csv", index=False) - + graph = create_graph_from_csv("test.csv") - + self.assertIsInstance(graph, nx.DiGraph) self.assertEqual(len(graph.edges()), 3) - self.assertEqual(graph['A']['B']['time_lag'], 5) - self.assertEqual(graph['B']['C']['time_lag'], 2) - self.assertEqual(graph['A']['C']['time_lag'], 7) + self.assertEqual(graph["A"]["B"]["time_lag"], (5,)) + self.assertEqual(graph["B"]["C"]["time_lag"], (2,)) + self.assertEqual(graph["A"]["C"]["time_lag"], (7,)) + + def test_multiple_time_lags(self): + csv_content = """node1,node2,time_lag +A,B,5 +A,B,3 +A,C,7""" + df = pd.read_csv(StringIO(csv_content)) + df.to_csv("test.csv", index=False) + + graph = create_graph_from_csv("test.csv") + + self.assertIsInstance(graph, nx.DiGraph) + self.assertEqual(len(graph.edges()), 2) + self.assertEqual(graph["A"]["B"]["time_lag"], (5, 3)) + self.assertEqual(graph["A"]["C"]["time_lag"], (7,)) + + def test_invalid_time_lag(self): + csv_content = """node1,node2,time_lag +A,B,five +B,C,2 +A,C,7""" + df = pd.read_csv(StringIO(csv_content)) + df.to_csv("test.csv", index=False) + + graph = create_graph_from_csv("test.csv") + + self.assertIsNone(graph) + + def test_empty_csv(self): + csv_content = """node1,node2,time_lag""" + df = pd.read_csv(StringIO(csv_content)) + df.to_csv("test.csv", index=False) + + graph = create_graph_from_csv("test.csv") + + self.assertIsInstance(graph, nx.DiGraph) + self.assertEqual(len(graph.edges()), 0) + + def test_self_loop(self): + csv_content = """node1,node2,time_lag +A,A,5""" + df = pd.read_csv(StringIO(csv_content)) + df.to_csv("test.csv", index=False) + + graph = create_graph_from_csv("test.csv") + + self.assertIsInstance(graph, nx.DiGraph) + self.assertEqual(len(graph.edges()), 1) + self.assertEqual(graph["A"]["A"]["time_lag"], (5,)) + + +class TestCreateGraphFromDotFormat(unittest.TestCase): - def test_create_graph_from_dot_format(self): + def setUp(self): + # Helper method to create a DOT file from string content + def create_dot_file(dot_content, file_name="test.dot"): + with open(file_name, "w") as f: + f.write(dot_content) + + self.create_dot_file = create_dot_file + + def test_basic_functionality(self): dot_content = """digraph G { -A -> B [label="5"]; -B -> C [label="2"]; -A -> C [label="7"]; +A -> B [label="(5)"]; +B -> C [label="(2)"]; +A -> C [label="(7)"]; }""" - with open("test.dot", "w") as f: - f.write(dot_content) - + self.create_dot_file(dot_content) graph = create_graph_from_dot_format("test.dot") - + self.assertIsInstance(graph, nx.DiGraph) self.assertEqual(len(graph.edges()), 3) - self.assertEqual(graph['A']['B']['time_lag'], 5) - self.assertEqual(graph['B']['C']['time_lag'], 2) - self.assertEqual(graph['A']['C']['time_lag'], 7) + self.assertEqual(graph["A"]["B"]["time_lag"], (5,)) + self.assertEqual(graph["B"]["C"]["time_lag"], (2,)) + self.assertEqual(graph["A"]["C"]["time_lag"], (7,)) - def test_create_graph_from_array(self): + def test_multiple_time_lags(self): + dot_content = """digraph G { +A -> B [label="(5,3)"]; +A -> C [label="(7)"]; +}""" + self.create_dot_file(dot_content) + graph = create_graph_from_dot_format("test.dot") + + self.assertIsInstance(graph, nx.DiGraph) + self.assertEqual(len(graph.edges()), 2) + self.assertEqual(graph["A"]["B"]["time_lag"], (5, 3)) + self.assertEqual(graph["A"]["C"]["time_lag"], (7,)) + + def test_invalid_time_lag(self): + dot_content = """digraph G { +A -> B [label="(five)"]; +B -> C [label="(2)"]; +A -> C [label="(7)"]; +}""" + self.create_dot_file(dot_content) + graph = create_graph_from_dot_format("test.dot") + + self.assertIsNone(graph) + + def test_empty_dot(self): + dot_content = """digraph G {}""" + self.create_dot_file(dot_content) + graph = create_graph_from_dot_format("test.dot") + + self.assertIsInstance(graph, nx.DiGraph) + self.assertEqual(len(graph.edges()), 0) + + def test_self_loop(self): + dot_content = """digraph G { +A -> A [label="(5)"]; +}""" + self.create_dot_file(dot_content) + graph = create_graph_from_dot_format("test.dot") + + self.assertIsInstance(graph, nx.DiGraph) + self.assertEqual(len(graph.edges()), 1) + self.assertEqual(graph["A"]["A"]["time_lag"], (5,)) + + +class TestCreateGraphFromNetworkxArray(unittest.TestCase): + + def test_basic_functionality(self): array = np.zeros((3, 3, 2), dtype=object) - array[0, 1, 0] = '-->' - array[1, 2, 0] = '-->' - array[0, 1, 1] = '-->' - array[2, 0, 1] = '-->' - - var_names = ['X1', 'X2', 'X3'] - - graph = create_graph_from_array(array, var_names) - + array[0, 1, 0] = "-->" + array[1, 2, 0] = "-->" + array[0, 2, 1] = "-->" + + var_names = ["X1", "X2", "X3"] + + graph = create_graph_from_networkx_array(array, var_names) + self.assertIsInstance(graph, nx.DiGraph) self.assertEqual(len(graph.edges()), 3) - self.assertTrue(graph.has_edge('X1', 'X2')) - self.assertEqual(graph['X1']['X2']['type'], 'contemporaneous') - self.assertTrue(graph.has_edge('X1', 'X2')) - self.assertEqual(graph['X1']['X2']['time_lag'], 1) - self.assertTrue(graph.has_edge('X3', 'X1')) - self.assertEqual(graph['X3']['X1']['time_lag'], 1) - -if __name__ == '__main__': + self.assertTrue(graph.has_edge("X1", "X2")) + self.assertEqual(graph["X1"]["X2"]["time_lag"], (0,)) + self.assertTrue(graph.has_edge("X1", "X3")) + self.assertEqual(graph["X1"]["X3"]["time_lag"], (1,)) + self.assertTrue(graph.has_edge("X2", "X3")) + self.assertEqual(graph["X2"]["X3"]["time_lag"], (0,)) + + def test_multiple_time_lags(self): + array = np.zeros((3, 3, 3), dtype=object) + array[0, 1, 0] = "-->" + array[0, 1, 1] = "-->" + array[1, 2, 2] = "-->" + + var_names = ["X1", "X2", "X3"] + + graph = create_graph_from_networkx_array(array, var_names) + + self.assertIsInstance(graph, nx.DiGraph) + self.assertEqual(len(graph.edges()), 2) + self.assertTrue(graph.has_edge("X1", "X2")) + self.assertEqual(graph["X1"]["X2"]["time_lag"], (0, 1)) + self.assertTrue(graph.has_edge("X2", "X3")) + self.assertEqual(graph["X2"]["X3"]["time_lag"], (2,)) + + def test_invalid_link_type_oo(self): + array = np.zeros((2, 2, 1), dtype=object) + array[0, 1, 0] = "o-o" + + var_names = ["X1", "X2"] + + with self.assertRaises(ValueError): + create_graph_from_networkx_array(array, var_names) + + def test_invalid_link_type_xx(self): + array = np.zeros((2, 2, 1), dtype=object) + array[0, 1, 0] = "x-x" + + var_names = ["X1", "X2"] + + with self.assertRaises(ValueError): + create_graph_from_networkx_array(array, var_names) + + def test_empty_array(self): + array = np.zeros((0, 0, 0), dtype=object) + var_names = [] + + graph = create_graph_from_networkx_array(array, var_names) + + self.assertIsInstance(graph, nx.DiGraph) + self.assertEqual(len(graph.nodes()), 0) + self.assertEqual(len(graph.edges()), 0) + + def test_self_loop(self): + array = np.zeros((2, 2, 1), dtype=object) + array[0, 0, 0] = "-->" + + var_names = ["X1", "X2"] + + graph = create_graph_from_networkx_array(array, var_names) + + self.assertIsInstance(graph, nx.DiGraph) + self.assertEqual(len(graph.edges()), 0) + + +if __name__ == "__main__": unittest.main() From afb9914eabe27c24db90aae2cf7a16e6de7f7820 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 1 Aug 2024 10:48:06 +0000 Subject: [PATCH 58/67] tests for adding lagged edges --- tests/timeseries/test_temporal_shift.py | 125 ++++++++++-------------- 1 file changed, 51 insertions(+), 74 deletions(-) diff --git a/tests/timeseries/test_temporal_shift.py b/tests/timeseries/test_temporal_shift.py index 49c54b653..8fdc53ef6 100644 --- a/tests/timeseries/test_temporal_shift.py +++ b/tests/timeseries/test_temporal_shift.py @@ -1,94 +1,71 @@ import unittest import pandas as pd +import networkx as nx from typing import List, Optional -from dowhy.timeseries.temporal_shift import shift_columns_by_lag +from dowhy.timeseries.temporal_shift import add_lagged_edges -class TestShiftColumnsByLag(unittest.TestCase): +class TestAddLaggedEdges(unittest.TestCase): - def test_shift_columns_by_lag_basic_shift(self): - df = pd.DataFrame({ - 'A': [1, 2, 3, 4, 5], - 'B': [5, 4, 3, 2, 1] - }) - columns = ['A', 'B'] - lag = [2, 2] - result = shift_columns_by_lag(df, columns, lag, filter=False) + def test_basic_functionality(self): + graph = nx.DiGraph() + graph.add_edge("A", "B", time_lag=(1,)) + graph.add_edge("B", "C", time_lag=(2,)) - expected = pd.DataFrame({ - 'A': [1, 2, 3, 4, 5], - 'B': [5, 4, 3, 2, 1], - 'A_lag1': [0, 1, 2, 3, 4], - 'A_lag2': [0, 0, 1, 2, 3], - 'B_lag1': [0, 5, 4, 3, 2], - 'B_lag2': [0, 0, 5, 4, 3] - }) + new_graph = add_lagged_edges(graph, "C") - pd.testing.assert_frame_equal(result, expected) + self.assertIsInstance(new_graph, nx.DiGraph) + self.assertTrue(new_graph.has_node("C_0")) + self.assertTrue(new_graph.has_node("B_-2")) + self.assertTrue(new_graph.has_node("A_-3")) + self.assertTrue(new_graph.has_edge("B_-2", "C_0")) + self.assertTrue(new_graph.has_edge("A_-3", "B_-2")) - def test_shift_columns_by_lag_different_lags(self): - df = pd.DataFrame({ - 'A': [1, 2, 3, 4, 5], - 'B': [5, 4, 3, 2, 1] - }) - columns = ['A', 'B'] - lag = [1, 3] - result = shift_columns_by_lag(df, columns, lag, filter=False) + def test_multiple_time_lags(self): + graph = nx.DiGraph() + graph.add_edge("A", "B", time_lag=(1, 2)) + graph.add_edge("B", "C", time_lag=(1, 3)) - expected = pd.DataFrame({ - 'A': [1, 2, 3, 4, 5], - 'B': [5, 4, 3, 2, 1], - 'A_lag1': [0, 1, 2, 3, 4], - 'B_lag1': [0, 5, 4, 3, 2], - 'B_lag2': [0, 0, 5, 4, 3], - 'B_lag3': [0, 0, 0, 5, 4] - }) + new_graph = add_lagged_edges(graph, "C") - pd.testing.assert_frame_equal(result, expected) + self.assertIsInstance(new_graph, nx.DiGraph) + self.assertTrue(new_graph.has_node("C_0")) + self.assertTrue(new_graph.has_node("B_-1")) + self.assertTrue(new_graph.has_node("B_-3")) + self.assertTrue(new_graph.has_node("A_-2")) + self.assertTrue(new_graph.has_node("A_-4")) + self.assertTrue(new_graph.has_edge("B_-1", "C_0")) + self.assertTrue(new_graph.has_edge("B_-3", "C_0")) + self.assertTrue(new_graph.has_edge("A_-2", "B_-1")) + self.assertTrue(new_graph.has_edge("A_-4", "B_-3")) - def test_shift_columns_by_lag_with_filter(self): - df = pd.DataFrame({ - 'A': [1, 2, 3, 4, 5], - 'B': [5, 4, 3, 2, 1], - 'C': [1, 1, 1, 1, 1] - }) - columns = ['A', 'B'] - lag = [1, 2] - result = shift_columns_by_lag(df, columns, lag, filter=True, child_node='C') + def test_complex_graph_structure(self): + graph = nx.DiGraph() + graph.add_edge("A", "B", time_lag=(1,)) + graph.add_edge("B", "C", time_lag=(2,)) + graph.add_edge("A", "C", time_lag=(3,)) - expected = pd.DataFrame({ - 'C': [1, 1, 1, 1, 1], - 'A': [1, 2, 3, 4, 5], - 'B': [5, 4, 3, 2, 1], - 'A_lag1': [0, 1, 2, 3, 4], - 'B_lag1': [0, 5, 4, 3, 2], - 'B_lag2': [0, 0, 5, 4, 3] - }) + new_graph = add_lagged_edges(graph, "C") - pd.testing.assert_frame_equal(result, expected) + self.assertIsInstance(new_graph, nx.DiGraph) + self.assertTrue(new_graph.has_node("C_0")) + self.assertTrue(new_graph.has_node("B_-2")) + self.assertTrue(new_graph.has_node("A_-3")) + self.assertTrue(new_graph.has_edge("B_-2", "C_0")) + self.assertTrue(new_graph.has_edge("A_-3", "B_-2")) + self.assertTrue(new_graph.has_node("A_-3")) + self.assertTrue(new_graph.has_edge("A_-3", "C_0")) - def test_shift_columns_by_lag_empty_dataframe(self): - df = pd.DataFrame(columns=['A', 'B']) - columns = ['A', 'B'] - lag = [2, 2] - result = shift_columns_by_lag(df, columns, lag, filter=False) + def test_no_time_lag(self): + graph = nx.DiGraph() + graph.add_edge("A", "B") + graph.add_edge("B", "C") - expected = pd.DataFrame(columns=['A', 'B', 'A_lag1', 'A_lag2', 'B_lag1', 'B_lag2']) + new_graph = add_lagged_edges(graph, "C") - pd.testing.assert_frame_equal(result, expected) - - def test_shift_columns_by_lag_unequal_columns_and_lags(self): - df = pd.DataFrame({ - 'A': [1, 2, 3, 4, 5], - 'B': [5, 4, 3, 2, 1] - }) - columns = ['A', 'B'] - lag = [1] - - with self.assertRaises(ValueError) as context: - shift_columns_by_lag(df, columns, lag, filter=False) - - self.assertTrue("The size of 'columns' and 'lag' lists must be the same." in str(context.exception)) + self.assertIsInstance(new_graph, nx.DiGraph) + self.assertEqual(len(new_graph.nodes()), 0) + self.assertEqual(len(new_graph.edges()), 0) if __name__ == '__main__': unittest.main() From a99558a1b7a459c963832f0b8527ec8836f0c222 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 1 Aug 2024 10:53:02 +0000 Subject: [PATCH 59/67] tests for shifting columns --- tests/timeseries/test_temporal_shift.py | 80 ++++++++++++++++++++++++- 1 file changed, 79 insertions(+), 1 deletion(-) diff --git a/tests/timeseries/test_temporal_shift.py b/tests/timeseries/test_temporal_shift.py index 8fdc53ef6..eafda57ba 100644 --- a/tests/timeseries/test_temporal_shift.py +++ b/tests/timeseries/test_temporal_shift.py @@ -2,8 +2,9 @@ import pandas as pd import networkx as nx from typing import List, Optional +from pandas.testing import assert_frame_equal -from dowhy.timeseries.temporal_shift import add_lagged_edges +from dowhy.timeseries.temporal_shift import add_lagged_edges, shift_columns_by_lag_using_unrolled_graph class TestAddLaggedEdges(unittest.TestCase): @@ -67,5 +68,82 @@ def test_no_time_lag(self): self.assertEqual(len(new_graph.nodes()), 0) self.assertEqual(len(new_graph.edges()), 0) +class TestShiftColumnsByLagUsingUnrolledGraph(unittest.TestCase): + + def test_basic_functionality(self): + df = pd.DataFrame({ + 'A': [1, 2, 3, 4, 5], + 'B': [5, 4, 3, 2, 1] + }) + + unrolled_graph = nx.DiGraph() + unrolled_graph.add_nodes_from(['A_0', 'A_-1', 'B_0', 'B_-2']) + + expected_df = pd.DataFrame({ + 'A_0': [1, 2, 3, 4, 5], + 'A_-1': [0, 1, 2, 3, 4], + 'B_0': [5, 4, 3, 2, 1], + 'B_-2': [0, 0, 5, 4, 3] + }) + + result_df = shift_columns_by_lag_using_unrolled_graph(df, unrolled_graph) + + assert_frame_equal(result_df, expected_df) + + def test_complex_graph_structure(self): + df = pd.DataFrame({ + 'A': [1, 2, 3, 4, 5], + 'B': [5, 4, 3, 2, 1], + 'C': [1, 3, 5, 7, 9] + }) + + unrolled_graph = nx.DiGraph() + unrolled_graph.add_nodes_from(['A_0', 'A_-1', 'B_0', 'B_-2', 'C_-1', 'C_-3']) + + expected_df = pd.DataFrame({ + 'A_0': [1, 2, 3, 4, 5], + 'A_-1': [0, 1, 2, 3, 4], + 'B_0': [5, 4, 3, 2, 1], + 'B_-2': [0, 0, 5, 4, 3], + 'C_-1': [0, 1, 3, 5, 7], + 'C_-3': [0, 0, 0, 1, 3] + }) + + result_df = shift_columns_by_lag_using_unrolled_graph(df, unrolled_graph) + + assert_frame_equal(result_df, expected_df) + + def test_invalid_node_format(self): + df = pd.DataFrame({ + 'A': [1, 2, 3, 4, 5], + 'B': [5, 4, 3, 2, 1] + }) + + unrolled_graph = nx.DiGraph() + unrolled_graph.add_nodes_from(['A_0', 'B_invalid']) + + expected_df = pd.DataFrame({ + 'A_0': [1, 2, 3, 4, 5] + }) + + result_df = shift_columns_by_lag_using_unrolled_graph(df, unrolled_graph) + + assert_frame_equal(result_df, expected_df) + + def test_non_matching_columns(self): + df = pd.DataFrame({ + 'A': [1, 2, 3, 4, 5], + 'B': [5, 4, 3, 2, 1] + }) + + unrolled_graph = nx.DiGraph() + unrolled_graph.add_nodes_from(['C_0', 'C_-1']) + + expected_df = pd.DataFrame() + + result_df = shift_columns_by_lag_using_unrolled_graph(df, unrolled_graph) + + assert_frame_equal(result_df, expected_df) + if __name__ == '__main__': unittest.main() From 64cb310d3f9ac60daa94288b4a7729ca03b0b80d Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 1 Aug 2024 10:54:24 +0000 Subject: [PATCH 60/67] formatting --- tests/timeseries/test_temporal_shift.py | 96 +++++++++++-------------- 1 file changed, 42 insertions(+), 54 deletions(-) diff --git a/tests/timeseries/test_temporal_shift.py b/tests/timeseries/test_temporal_shift.py index eafda57ba..1fc42c3a6 100644 --- a/tests/timeseries/test_temporal_shift.py +++ b/tests/timeseries/test_temporal_shift.py @@ -1,20 +1,22 @@ import unittest -import pandas as pd -import networkx as nx from typing import List, Optional + +import networkx as nx +import pandas as pd from pandas.testing import assert_frame_equal from dowhy.timeseries.temporal_shift import add_lagged_edges, shift_columns_by_lag_using_unrolled_graph + class TestAddLaggedEdges(unittest.TestCase): def test_basic_functionality(self): graph = nx.DiGraph() graph.add_edge("A", "B", time_lag=(1,)) graph.add_edge("B", "C", time_lag=(2,)) - + new_graph = add_lagged_edges(graph, "C") - + self.assertIsInstance(new_graph, nx.DiGraph) self.assertTrue(new_graph.has_node("C_0")) self.assertTrue(new_graph.has_node("B_-2")) @@ -26,9 +28,9 @@ def test_multiple_time_lags(self): graph = nx.DiGraph() graph.add_edge("A", "B", time_lag=(1, 2)) graph.add_edge("B", "C", time_lag=(1, 3)) - + new_graph = add_lagged_edges(graph, "C") - + self.assertIsInstance(new_graph, nx.DiGraph) self.assertTrue(new_graph.has_node("C_0")) self.assertTrue(new_graph.has_node("B_-1")) @@ -45,9 +47,9 @@ def test_complex_graph_structure(self): graph.add_edge("A", "B", time_lag=(1,)) graph.add_edge("B", "C", time_lag=(2,)) graph.add_edge("A", "C", time_lag=(3,)) - + new_graph = add_lagged_edges(graph, "C") - + self.assertIsInstance(new_graph, nx.DiGraph) self.assertTrue(new_graph.has_node("C_0")) self.assertTrue(new_graph.has_node("B_-2")) @@ -61,89 +63,75 @@ def test_no_time_lag(self): graph = nx.DiGraph() graph.add_edge("A", "B") graph.add_edge("B", "C") - + new_graph = add_lagged_edges(graph, "C") - + self.assertIsInstance(new_graph, nx.DiGraph) self.assertEqual(len(new_graph.nodes()), 0) self.assertEqual(len(new_graph.edges()), 0) + class TestShiftColumnsByLagUsingUnrolledGraph(unittest.TestCase): def test_basic_functionality(self): - df = pd.DataFrame({ - 'A': [1, 2, 3, 4, 5], - 'B': [5, 4, 3, 2, 1] - }) + df = pd.DataFrame({"A": [1, 2, 3, 4, 5], "B": [5, 4, 3, 2, 1]}) unrolled_graph = nx.DiGraph() - unrolled_graph.add_nodes_from(['A_0', 'A_-1', 'B_0', 'B_-2']) + unrolled_graph.add_nodes_from(["A_0", "A_-1", "B_0", "B_-2"]) - expected_df = pd.DataFrame({ - 'A_0': [1, 2, 3, 4, 5], - 'A_-1': [0, 1, 2, 3, 4], - 'B_0': [5, 4, 3, 2, 1], - 'B_-2': [0, 0, 5, 4, 3] - }) + expected_df = pd.DataFrame( + {"A_0": [1, 2, 3, 4, 5], "A_-1": [0, 1, 2, 3, 4], "B_0": [5, 4, 3, 2, 1], "B_-2": [0, 0, 5, 4, 3]} + ) result_df = shift_columns_by_lag_using_unrolled_graph(df, unrolled_graph) - + assert_frame_equal(result_df, expected_df) def test_complex_graph_structure(self): - df = pd.DataFrame({ - 'A': [1, 2, 3, 4, 5], - 'B': [5, 4, 3, 2, 1], - 'C': [1, 3, 5, 7, 9] - }) + df = pd.DataFrame({"A": [1, 2, 3, 4, 5], "B": [5, 4, 3, 2, 1], "C": [1, 3, 5, 7, 9]}) unrolled_graph = nx.DiGraph() - unrolled_graph.add_nodes_from(['A_0', 'A_-1', 'B_0', 'B_-2', 'C_-1', 'C_-3']) - - expected_df = pd.DataFrame({ - 'A_0': [1, 2, 3, 4, 5], - 'A_-1': [0, 1, 2, 3, 4], - 'B_0': [5, 4, 3, 2, 1], - 'B_-2': [0, 0, 5, 4, 3], - 'C_-1': [0, 1, 3, 5, 7], - 'C_-3': [0, 0, 0, 1, 3] - }) + unrolled_graph.add_nodes_from(["A_0", "A_-1", "B_0", "B_-2", "C_-1", "C_-3"]) + + expected_df = pd.DataFrame( + { + "A_0": [1, 2, 3, 4, 5], + "A_-1": [0, 1, 2, 3, 4], + "B_0": [5, 4, 3, 2, 1], + "B_-2": [0, 0, 5, 4, 3], + "C_-1": [0, 1, 3, 5, 7], + "C_-3": [0, 0, 0, 1, 3], + } + ) result_df = shift_columns_by_lag_using_unrolled_graph(df, unrolled_graph) - + assert_frame_equal(result_df, expected_df) def test_invalid_node_format(self): - df = pd.DataFrame({ - 'A': [1, 2, 3, 4, 5], - 'B': [5, 4, 3, 2, 1] - }) + df = pd.DataFrame({"A": [1, 2, 3, 4, 5], "B": [5, 4, 3, 2, 1]}) unrolled_graph = nx.DiGraph() - unrolled_graph.add_nodes_from(['A_0', 'B_invalid']) + unrolled_graph.add_nodes_from(["A_0", "B_invalid"]) - expected_df = pd.DataFrame({ - 'A_0': [1, 2, 3, 4, 5] - }) + expected_df = pd.DataFrame({"A_0": [1, 2, 3, 4, 5]}) result_df = shift_columns_by_lag_using_unrolled_graph(df, unrolled_graph) - + assert_frame_equal(result_df, expected_df) def test_non_matching_columns(self): - df = pd.DataFrame({ - 'A': [1, 2, 3, 4, 5], - 'B': [5, 4, 3, 2, 1] - }) + df = pd.DataFrame({"A": [1, 2, 3, 4, 5], "B": [5, 4, 3, 2, 1]}) unrolled_graph = nx.DiGraph() - unrolled_graph.add_nodes_from(['C_0', 'C_-1']) + unrolled_graph.add_nodes_from(["C_0", "C_-1"]) expected_df = pd.DataFrame() result_df = shift_columns_by_lag_using_unrolled_graph(df, unrolled_graph) - + assert_frame_equal(result_df, expected_df) -if __name__ == '__main__': + +if __name__ == "__main__": unittest.main() From 30b986ba59ce90171cd0b563ad9b3de720bcc9aa Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Thu, 1 Aug 2024 10:56:24 +0000 Subject: [PATCH 61/67] formatting --- dowhy/timeseries/temporal_shift.py | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index af1db990f..414d63b71 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -1,5 +1,5 @@ -from typing import List, Optional, Tuple from collections import deque +from typing import List, Optional, Tuple import networkx as nx import pandas as pd @@ -24,16 +24,16 @@ def add_lagged_edges(graph: nx.DiGraph, start_node: str) -> nx.DiGraph: while queue: current_node = queue.popleft() - + for parent in graph.predecessors(current_node): edge_data = graph.get_edge_data(parent, current_node) if "time_lag" in edge_data: parent_time_lag = edge_data["time_lag"] - + # Ensure parent_time_lag is in tuple form if not isinstance(parent_time_lag, tuple): parent_time_lag = (parent_time_lag,) - + for lag in parent_time_lag: # Find or create the lagged node for the current node if current_node in lagged_node_mapping: @@ -43,11 +43,11 @@ def add_lagged_edges(graph: nx.DiGraph, start_node: str) -> nx.DiGraph: lagged_nodes.add(f"{current_node}_0") new_graph.add_node(f"{current_node}_0") lagged_node_mapping[current_node] = lagged_nodes - + # For each lagged node, create new time-lagged parent nodes and add edges new_lagged_nodes = set() for lagged_node in lagged_nodes: - total_lag = - int(lagged_node.split('_')[-1]) + lag + total_lag = -int(lagged_node.split("_")[-1]) + lag new_lagged_parent_node = f"{parent}_{-total_lag}" new_lagged_nodes.add(new_lagged_parent_node) @@ -58,7 +58,7 @@ def add_lagged_edges(graph: nx.DiGraph, start_node: str) -> nx.DiGraph: # Add the parent to the queue for further exploration queue.append(parent) - + # append the lagged nodes if parent in lagged_node_mapping: lagged_node_mapping[parent] = lagged_node_mapping[parent].union(new_lagged_nodes) @@ -68,10 +68,7 @@ def add_lagged_edges(graph: nx.DiGraph, start_node: str) -> nx.DiGraph: return new_graph -def shift_columns_by_lag_using_unrolled_graph( - df: pd.DataFrame, - unrolled_graph: nx.DiGraph -) -> pd.DataFrame: +def shift_columns_by_lag_using_unrolled_graph(df: pd.DataFrame, unrolled_graph: nx.DiGraph) -> pd.DataFrame: """ Given a dataframe and an unrolled graph, this function shifts the columns in the dataframe by the corresponding time lags mentioned in the node names of the unrolled graph, creating a new unique column for each shifted version. @@ -85,8 +82,8 @@ def shift_columns_by_lag_using_unrolled_graph( """ new_df = pd.DataFrame() for node in unrolled_graph.nodes: - if '_' in node: - base_node, lag_str = node.rsplit('_', 1) + if "_" in node: + base_node, lag_str = node.rsplit("_", 1) try: lag = -int(lag_str) if base_node in df.columns: @@ -94,5 +91,5 @@ def shift_columns_by_lag_using_unrolled_graph( new_df[new_column_name] = df[base_node].shift(lag, axis=0, fill_value=0) except ValueError: print(f"Warning: Cannot extract lag from node name {node}. Expected format 'baseNode_lag'") - - return new_df \ No newline at end of file + + return new_df From 8c80c021c6da96c625f645007582095c756b5f21 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 2 Aug 2024 08:36:45 +0000 Subject: [PATCH 62/67] inter node links --- .../effect_inference_timeseries_data.ipynb | 5746 ++++++++++++++++- dowhy/timeseries/temporal_shift.py | 7 + 2 files changed, 5728 insertions(+), 25 deletions(-) diff --git a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index 5d3dc959c..c622ca293 100644 --- a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -50,9 +50,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAboAAAGFCAYAAACL2zb9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAADVGUlEQVR4nOydd3ib13nofwBIkMQkSBDce1OckihRw9qyLA/Zlu14ZDppGtd10qRNbjOcm7Rp0ySNc++t07RpnDjDjlfiWLEl2doSZUmURImkSHHvPQESAAFi3j/c76tkDUs2RYDk93sePBpY7/fhnPOe806Z3+/3IyEhISEhsUCRB1oACQkJCQmJW4mk6CQkJCQkFjSSopOQkJCQWNBIik5CQkJCYkEjKToJCQkJiQWNpOgkJCQkJBY0kqKTkJCQkFjQSIpOQkJCQmJBIyk6CQkJCYkFjaToJCQkJCQWNJKik5CQkJBY0EiKTkJCQkJiQSMpOgkJCQmJBU1IoAUIBELDBq/Xi9/vx+fz4fP5xOcv/btMJhP/FB5yuVx8CM9LSCxWhPkkzCOfz4ff77/s/wWuNp9kMhkKhUKcWxISs82iVXQ+n4+xsTGsVqv48Hq9+Hw+bDabOFkjIiIICQkhJCSE8PBwVCoVKpUKo9GIVqslNDQ00JcjIRFwfD4fZrMZu93OxMQENpsNj8eDz+fDbrfj9Xrxer2Eh4cTGhoqzqfw8HAiIiIwmUyo1WoiIiICfSkSC5AFp+h8Ph8ej4f+/n4sFgujo6MMDw8zOTnJxMQE4+PjOBwO8eF2u8WHsAO99O8KheKyE5yg9MLCwoiIiCAsLAydTkd0dDQ6nQ6j0YjJZMJgMBATE4PJZCIkJEQ6+UnMS/x+P263m/HxcSYmJhgYGGBiYoLJyUlxXk1PT2O1WpmZmcHtduNyucQ55Pf78Xg84t8vPbkpFArxER4eTlhYGGFhYURGRqLT6dDr9cTFxWEwGIiMjCQxMZGoqChRGUpzSuJGmbeKTlBELpcLl8vF9PQ0TqeTmZkZbDYbbW1tjI2NMTQ0xODgoKjoxsbGcDqdOJ3Oy8yQwgQELjOfCBNUeAimGa/Xi1wuJzQ0VFRwOp2OmJgYYmNjMRqNJCQkkJ6ejkqlukwxhoeHS8pPIqgQ5pPH48HlcmG323G5XMzMzDA1NcXAwABDQ0P09PQwPj6OxWJhaGhIVHR2u/0yM6RCoQCuNFEKlhJA/LuwORXeGxkZiV6vR6fTER8fT3R0NAaDgYyMDBISEtDr9URERBAeHo5SqUSlUhESEiKZPSWuiWy+dhgXFE9zczNdXV2cOHGC2tpaenp6aG5uxuVyERISglarJSsrC5PJRFJSEunp6ej1evR6PbGxsWi1WrRaLZGRkaLSU6vVouITTn1er1dUona7ndHRUSYmJpiammJ0dJTOzk5GRkbo7e2lo6MDh8OB1+slKiqKpKQkcnJyqKioYMmSJSxZsoSEhARpYkoEDcJ8GhwcpKOjgyNHjtDa2kpbWxt1dXXMzMzg9/vR6/UkJiYSGxtLVlYWCQkJGAwGjEYj0dHRaLVaDAYDOp2O0NBQZDKZqIgUCgUOhwOPx4PH42FmZgaHw4Hdbmd4eJipqSkmJycZHBxkaGiI4eFhWltbGRgYwGKx4Ha70el0REVFUVZWRklJCVlZWaxduxaTyUR4eHigb6NEkDKvFJ3L5aK9vZ3Gxka6urq4cOECg4ODTE9PI5PJiIqKEk9XaWlpGAwGoqKi0Gg04klKrVYTEhJCaGgoYWFhoilSmJSXOsbhfwJWLt15CkrP5XJdtgMWJq7VahVNO93d3UxOTjI5Ocno6CihoaGoVCpyc3NJT08nPT2dVatWodVqpYkqMaf4/X46Ojro7u6mqamJmpoaRkdHGR8fRyaTodFoxA1hfHy8aK0QLBNqtVo8VQkPYS5desK61Hpx6SlOsIwI88ntduPxeESLy8zMDHa7XTwx9vT0MDQ0hNlsZmxsDLPZjNfrRa1Wi6e9goICli9fTlRUFFqtNpC3VyKICGrTpTARzGYzU1NTWCwWampqaGxspKenh7a2NrxeL2FhYSQnJ5OTk0N8fDzZ2dnk5eVhMBgwGAwfSYaQkJu7RcIknpqaYnBwkIsXL9Lf3093dzcOhwOz2czo6Ch2u52hoSH6+/uRyWTExcURFRVFdHQ0KpUKpVL5keSWkHg/wti0WCzY7XYsFgu1tbV0dXXR3NwsWkIA0tLSSEpKIjk5mcLCQlJSUoiLiyMmJuYjmdwFk+bN4PP5mJmZoauri87OTgYGBmhqaqKtrY3R0VG6u7uxWq309fUxNjaG2+0mISFBNHsKQWQSi5egPtEJ/oHXX3+dI0eOcP78eZqbm0lOTiY1NZUtW7awatUqMjIyyMzMvOpnBMIPdq1b6na76erqoqmpiX379olKe2pqisLCQoqLi3n00UcpLi4mISFhjqWWWOh4PB4cDgdvvfUWZ8+eZd++fbS0tKDRaEhJSeGOO+6gsLCQ0tJScnNzr6qUgmk+eTwezGYz1dXVVFZW0tDQwIkTJ7BarZhMJsrLy3nkkUcoKChgyZIlcyy1RDARdIrO7XbjcDg4cuQIp0+fpq6ujq6uLtEPsHLlSvLz80lISBBNlREREURERAR1cIdg/nQ6nUxPTzM+Pi4GyJw+fZr29nYGBgYYHx8nLS2NjIwM7r77bpYsWYLRaASkKDOJm8fr9eJyuTh58iQNDQ0cOnSI3t5eFAoFMTExrFixgvT0dHJzc4mOjkatVqPRaFCr1UE/3gRXgtVqxWKxYLPZGB8f59y5c3R3d9Pa2sr4+DiRkZFkZGRw7733kpOTI26Kg/36JGaPoDBdCkpgeHiY4eFh+vv7OXr0KG1tbQwMDBATE0N2djaZmZls3LiR9PR0oqOjAy32TSH4/y7NwxN8E2q1mujoaJqamjhz5gz9/f1MTk6iUqmwWq2kpaWRmpoqOvUlJK6HsHcVUgI6Ozs5efKk6I8TwvYLCgpYv349qamppKamBljqm0cul6NUKomOjiY6Olp0deh0OlpbWwkLC+Ps2bNMTk5SV1dHZGQkIyMjTE5OkpGRIUZDSyx8An6iuzRN4Pe//z3vvPMO+/fvx+PxsHr1atatW8dnP/tZ9Hr9gg/WmJmZ4eLFi7z++uu8++67HDlyhKysLEpKSvja175Gbm4uOp1OfL20I5V4P5eG7u/Zs4fjx4/zy1/+Eo/HQ0pKCvfeey+f+MQnSExMRKPRBFjaW4vf7+fixYucOnWKN954g4MHD6LX68nOzuYf/uEfyMnJucxFIM2nhUtAFZ0Q9VVVVcXbb7/NmTNniIuLIzs7mwceeID4+HiMRiMxMTFi4vZCxufziQEr4+Pj1NXVsX//ftrb25mammLz5s0sW7aM++67D5VK9aEc+xILm/7+ftra2nj++edpaGjA6/VSXFzMHXfcQXp6OomJiURHR6NUKhf8+PH7/WL6wvj4OLW1tZw7d46TJ09isVgoLCxkxYoVfOpTn0Kj0UgBYAuYObeDCXrVarUyODjIkSNHqKuro7W1lcTERAoLCykvL6e8vHzRDT4hh0+tVmMymdBqtTgcDnQ6HadOnaK5uRmn04lGo6GsrEzMW5JY3AjVS7q7uzl37hwXL16kqakJrVZLfHw869evp6KiQkwNWCy831VwqS//2LFjDA0NcfLkSRISEsjNzSUlJYXIyEjpZLcAmdMTnfBVfr+f+vp63nrrLf7f//t/hIeHk5ubyz/+4z+Snp5ObGzsXIkU9Pj9fsbHx3n77bf5xS9+QXt7OyEhIXz3u99lxYoV5OfnA5LZZTFy6XyamJjgV7/6FS+//DJdXV0UFxfz13/91yxfvpz09PQASxo8CJuCXbt2sXv3bvbt24dSqeSxxx7jvvvuY9myZVKx9gXInCo6t9uN3W7nmWee4dy5c1y4cIG77rqLiooK1q1bR2xsrJh0KvEefr8fr9eLzWajp6eH+vp6fvWrXzE0NERKSgoPPfQQ991330fOF5SYfwgFyF955RUOHz5MZWUlq1evpqysjI997GNER0cTERGxqKwiH4Sw3AkVjXp6enjmmWcYGhrC7/fzV3/1V6xbt47c3NwASyoxm8yJRhHC6gcGBjh9+jTV1dXY7XbKyspYv349hYWFpKWlAdLJ5P3IZDJCQkKIjIxEqVQSFhbGwMAABw8exOFwcODAAdGvmZGRIUZ3SixsXC4XU1NTHDp0iFOnTtHd3U1JSQlr1qyhrKxMPMVJY+FyhPshBLfp9Xpuv/12zp49S3t7O4cOHUIul+N0OikqKpLm0wLhlis6YQc1MTFBVVUV//zP/4zT6eS2227ji1/8IoWFhVKI7w2iUqnIycnhb//2b0lKSuLQoUP89re/xePxsGXLFpKTk1Eqlfj9fmlyLlAu9XF3dHTw/e9/H7vdjslk4n//7/9NVlYWUVFRAZZyfhAWFobRaORLX/oSlZWVHD58mB/96EcMDQ3R2dlJTk4OSqVSDIKT5tT85ZabLh0OB8PDw3zjG9+gpaUFj8fDP/7jP7JkyRJxYZYG0I0j/FxC7b9jx47x05/+lPDwcFatWsXTTz+N0Whc8BF1ixWv10t/fz/PP/88b731Fk6nk8cff5wtW7aQk5NDaGio9NvfBMJ8cjqdWCwWdu/ezeuvv05TUxPbtm3j8ccfl/x2C4BbeqJzOp309vaye/du+vr6iIyMZO3atRQWFhIXFyed5D4EwmTTaDQkJiZSUVHBhQsX6Orq4syZMxw7dozCwkLy8vIue73E/MflcmG1Wvnzn/9MfX09Ho+He++9lxUrVpCWlkZYWJj0e98kwv0SGiyvWLGC0dFRwsPDqa6uJjs7G5/Px8qVKyVLyTzmlig6YZdksVior6/npz/9KTExMaxatYqvfOUraLVaadc5C+j1ekpKSviLv/gL9uzZwzPPPMOrr76K1WolMzNT6n6+QLj0FN/b28t//ud/olQqSU9P58tf/jI6nU4KOJkFQkNDKS4uRqVSkZWVxRNPPMGePXsYHx+nrKxM7HAiMf+4ZYrO6XTyL//yL5w5c4bQ0FC+/e1vU1ZWhk6nkwbLLFNYWIhWqyUlJYXvfOc7jI2NMTU1xec//3nUanWgxZOYBZxOJ3/4wx944YUX8Hq9PPbYY+zcuRODwbDgCynMNWlpaURFRfHss8/y3HPP8eqrrxIZGckDDzxARkZGoMWT+BDckhkyOTnJwYMHaWxsBODhhx8mNzeXqKgoydY9y8hkMkJDQzGZTCxbtow1a9YQFhbGvn376OjowGw2B1pEiY+Ix+Ph2LFjnDt3jpGREe6//37Ky8uJi4uT5tMtICQkBI1Gw7Jly1i1ahVZWVns27ePxsZGhoaGAi2exIdg1hWdx+NhdHSUP/3pTwwODmIymfjc5z5HcnLygq9VGUh0Oh15eXns2LGD+Ph4jh8/Tl1dnZgfFGRNKiRuEK/Xi9Pp5K233qKhoQG5XM6nP/1pli5dikqlkpTcLUKpVJKbm8vWrVtZvXo1lZWVnD9/no6ODmk+zUNm3XRZW1vL8ePH+f3vf8/f/d3fsX79ehITEyXzyhwgk8m49957iYiIYHx8nO9///s8+uijfPGLX7ysGLTE/KGnp4fz58/z8ssvs3HjRp566inS0tIkn9wcsWbNGhISEqiuruZPf/oTtbW1LFmyBLVaLRW2mEfM2i8lVPA4deoUZ86cIT8/n2XLlpGXlzdngSfj4+O0t7fzxhtvXPGcUqlEp9Pxuc99Dr1ef4XsMzMzHDx4kHffffeK9z700EOUlZWJ/3Y4HPT09HDq1CmGhoaYmpriiSeeIDk5edav6WaQyWTiTnTnzp18//vfp7W1lcrKSm6//XZpcZxHCN3AW1pa2Lt3L2lpaZSUlMxpUITVamV0dJTf/OY3uN3uy56Ty+VERkZyzz33XLWKyMzMDC0tLbz00ktXPLd8+XJ27tx51e90Op386U9/or+/H7vdzpo1aygoKAhYI+LQ0FBiYmL42Mc+xi9+8QsGBgY4fPgwa9euFftESgQ/s6bohHJEZ86cob6+noqKCpYsWUJKSspsfcUHMjU1RXNzM7/61a+w2Wy43W5cLhcRERFERUWRlpbGI488coWig/dCt6uqqnjuueeYmppCoVCgUChQqVQsXbqU0tJSvF4vDoeD8fFxampqePHFF2loaGB4eJh777034IpOICUlBZ1Ox7//+7/T19fHkSNHWL9+PSEhIdLJeh5hs9loaWnhyJEjrFu3jtLSUrKzs+fs+x0OB4ODg/z2t7/FbDYzMzOD0+lEqVSiVqvJzs6mrKzsqorO7XbT1dXFr371K6xWKz6fj5CQECIiInA6nVdVdG63m8nJSV5++WVqa2sxm834/X6io6MDpujgPbfAnXfeyZ49e7h48SIHDhygoKAAg8EgRY/PE2ZN0VksFl566SXq6+sJDw/na1/72pwPztTUVJKSkti5cyc//OEPOX78OIcPH+bRRx9l06ZN7Ny585q5e1qtlqeffponnniCp556ioSEBHJycnj88ceJiIjA7XbT19fHb37zG86fP8/AwAD9/f1YrdY5vcYbQalUEhUVxec+9zn27dvHiy++yGc+8xmSk5OvquQlgg+v18vrr79OZWUlk5OTPPnkk3NenDkmJobo6GgaGhp47bXXeOutt3j99dfZtGkTGzZs4Kmnnrqm312tVrN9+3ba29v5X//rf2G1WsnNzeUzn/nMNU9CjY2NnDx5koMHDzI9PR00nTnkcjl6vZ6dO3diNBr55S9/yebNm4mMjMRkMgVaPIkbYFa2936/H6vVyv79+4mJiWH58uWYTKY5z+OSy+WEhoaKp7CCggLgvQnU29t7zYRaoZ6d3+/H5XLR1taG0WikvLxctMVbrVbefPNNXC4XRUVFfOUrXyEjIyMoc9VkMhkKhYI1a9aQm5tLaGgo7777Lj09PYEWTeIGENwAx44dw263s3r1auLj4+c8VUQYR0LpuRUrViCXy+np6aGxsZGwsLBrWgiEeeb1eunu7sbj8bBmzRoMBsMVm02/38/U1BTV1dW8+eabFBYWBpUCEdaH4uJili9fTnh4OHV1ddTV1QVaNIkbZFYUncvlwmw2U11dTVxcHCUlJWg0moA6a3Nzc8nMzCQkJIS2tja6u7txOBzXjZay2+2Mjo4yOjpKZGQk2dnZ4oR1uVy0t7djMBgoKyvj4YcfJjExMWgd0jKZjLy8PNLT04mMjKS6upq+vj4pYmwe4PF4sNvt1NbW4vV6WbFiBZGRkQGtJJSUlMSSJUtQKpUMDg7S0tLC9PQ0Xq/3mu9xuVzifAIoKCi4qp/Y5/PR19dHU1MTFy9eZMmSJUGl6ATS0tLIzc3FZDLR0tJCY2OjNJ/mCbOi6FpaWjh79iwDAwMsX76czZs3z8bHfmhkMhm5ubkUFhaSmprK5OQkra2tnDx5kpmZmWu+r6GhgQMHDlBeXk5WVhbR0dHicyaTiX/+53/my1/+Mvfffz8KhSLoQ7tDQkLIz8/nzjvvFPOAPB5PoMWS+ACGh4c5efIkvb29xMfHs3PnzoAHEiUlJVFaWkpaWhper5eenh5OnjzJ+Pj4Nd8zPDzMG2+8QXp6OsXFxcTExFzVp+Vyufj+979PT08P27ZtY+3atQH1yV0LhUJBbGwsO3fu5OLFixw/flyaT/OEWVF0ra2tNDY2kpmZSUpKSlDsxuRyOUajkXXr1qFSqRgeHqayshKn03nN93R0dFBdXc3q1atJTEy8rEWHXC4X6+HNByUnyJ6SksLq1avF8lEtLS3SDjTIGRkZ4fTp08THx5OWlkZCQkLAg4hkMhnh4eGsXbuW2NhYHA4Hx44dE09rV2NiYoKjR4+Sm5tLQUHBVVve9PX1UVlZSWdnJykpKTz44INBW+hdJpOh0+nYsGEDCoWCkZERLl68eN01RSI4mJXZ09/fT09PD2lpaRiNRjQaTVAM1MjISJYuXUp4eDhms5mamhqcTic+n++y1/n9fjHCrKuri6Kioisc5kJfuEAvODdLVFQUOTk5yGQyJiYm6OnpueL6JYILs9lMU1MT8fHxxMXFodPpgmLcKZVKysrKMBqNzMzMcP78eSYmJvB6vVdsnmZmZpiYmKC5uZm0tDSx36SA0Om7t7eXqqoqQkJCSEtLo6ysLKgjGVUqFfn5+YSHh2O32+ns7LyulUgiOJiV2dPV1UVXVxcVFRVB1ek6Li6Oe+65B51Ox/DwMIcPH2ZsbOyKHZjX66WhoYHu7m6mp6eD1nTyYdBoNCQkJJCcnIzNZqOurk5SdEHO2NgYtbW1FBcXk5qaGmhxRMLDw7nrrrtITU3F4XBw+PBhcc68n/b2dlpaWpiYmKC0tFQMDLuUsbExDh8+zH/8x3/w5S9/mW3btqFSqebiUj40oaGhxMfHi5Wezp07h8PhCLRYEh/AR1J0Pp9PbElvtVrJy8tDo9HMlmwfGaVSidFoZMmSJSQmJuJ0OqmqqqK9vf2y1wm1BOVyOatWrbqs2eJ8R4icy8nJwe/309bWJpkugxS/34/NZmNiYoLh4WHS0tKCwg0goFAoMBqNZGVlkZubi9vtpqGhgXPnzl3x2rNnz9Lb28v69evR6/VXzCev18uvf/1rurq6WLt2LaWlpcTGxs7VpXxoBPNramoqUVFRNDc3S6bLecBHVnQ2m01Mzo6Pjw+qepYKhYKIiAiysrJISEjA6/Vy8eJF+vr6xNcIJpS6ujoUCgVFRUWEhIQEhel1tpDL5cTFxQHv+X8kRRe82O12bDYb09PTmEymoCrdJpPJiIiIIDk5mczMTHw+H52dnTQ3N4uvubSiy+joKGVlZahUqssUncPhYGRkhLNnz+JyuVi5ciWxsbHzqtOG4KIZHBy8omqMRPDxkRSd1+tlcHAQh8NBaGgoqampREREzJZss4JMJmPDhg2UlZXh9/s5ePAg9fX14vNCKPehQ4eIiIjg9ttvD2ofwYdBJpORlJSETCZjeHhYUnRBzOjoKJOTk8B7kY7B5AoQKCkpYdOmTchkMqqrqzl69Kj4nM/nY2ZmhqqqKvr6+tixY8cVRQq6u7vZtWsX7e3tpKWl8cQTTwTduvFBmEwm9Hq9pOjmCR8pCUwwXbrdbuRyOTqdLigTqMvKyujs7ESlUtHZ2Snm1SUlJdHX10ddXR0xMTGkpKSQmpq6oE5z8J6iE6pMWK1WSdEFMVarFYfDIf5mwWQhEcjOzsblcqHRaBgZGaG1tZWuri7i4uJwOp2cOXOGsLAw4uLiSE9PF1Mj/H4/ExMTnDlzhl//+td84hOfoKKiIiiv8YNQq9UolUqmpqYkn/c84CMpOqEYstfrRS6XX7dSQiAxGo3Ex8eTkJBAZ2cnQ0NDtLe3ExcXx/DwMI2NjSQnJ2MymeaV+eRGEULDASlCLIgRKvMIJwSlUhmUBQl0Oh1xcXEkJCTQ19fHxMQEbW1taLVaZmZmqKurQ6/Xk5SUdIXPfmhoiM7OTpqamrDb7XR3d192InK73Vy8eJGJiQk8Hg+dnZ2cPXsWi8UCvKdkjUbjNasczRXCb3O1KG6J4GNWFJ3P50MmkwWlohMakyYmJrJhwwaGhobo7u5m3759lJeX09HRwZEjR7jjjjvIzMwMtLi3DEHROZ1O6UQXxLhcLjEJOVgVXUhICDqdjo0bN/LOO+8wNTXF3r17SU5OxuPxsGfPHjZs2MDSpUsve5/f7+f8+fM0NzczNTXFd7/73Q/8rt/+9rf89re/Ff/9//7f/+O+++4LeAH1sLAwUdFJ8yn4+UizSC6Xo9VqCQkJwefzYbVa0el0Aa/icDUSExO566672LVrFz09Pezbt4/HHnuMtrY2Wlpa+Jd/+ZegCuWeTYRapPBe8eqFZppdSKjVanFTYrPZcDqdQWll0Gg03HXXXdTV1dHf38/bb7/NbbfdRmhoKPX19fz1X//1FYpOJpNxxx13UFFRwRe/+MWrfq7b7ebo0aPs3r2bCxcu8Mgjj7Bu3TpycnKA98pwBYPf0m63MzMzEzQ5jhLX5yMpOiEKS1B009PTQTkp4T1zS3Z2NpGRkQwODtLX10dVVRWDg4NoNBri4uKCKjVithFyneab038xIZiYhY2iw+EI2kCH0NBQsrOziYmJQalUMjAwwPnz59FoNKjVakwm0xUKSSaTYTQaxRSFq+F0Ounv7ycyMhKFQkFSUhJFRUWX9YMMBpxOJ263+4qIUongZNZOdF6vl8nJSSIjI4NyMRUUXWpqKlNTU4yMjPCzn/0Mk8lEeXl50J5EZwOhOjwQNFVrJK6ORqMhPDxcPIUHa46WUqkkJyeHtLQ0YmJi6Ojo4JVXXiE2NpaKigpMJlNQrgOzhc1mY2ZmBq1Wu+CitBciH2krEhISQkpKCnq9Hr/fT1NTEzabbbZkm3Xkcjlbt26luLgYn89HU1MTOp2Ou+66KyijRWcLr9dLc3Mzfr+fjIwMSdEFMQkJCcTExBAaGkp7ezsjIyOBFum6lJeXs2HDBuC9CkmTk5Pcd999REVFBVawW0x3dzdjY2NkZ2cHtKuExI0xK6bLyMhIVCoVvb29QV0ORyaTsWTJEpqbm8UKB0ajkZycnA/clbndbkZGRqivr2dsbAx4b7DPzMzg9/t55513aG1tBaC4uBiTyRQUlR6EBN6BgQH0en1QFAiWuDbh4eFotVqioqIYGhoSow2DlfT0dPLz88X5JNSCvJlSXl6vl9raWoaHhxkeHqa6upqBgQHcbjcXLlxAqVTS0tJCTEwMS5YsCei8EgJPRkZGsNlsYr9HieDmIyu60NBQTCYTMTExtLS0YLfb8fv9QXlqkMlklJeXi13QY2JiSE9PFyurXw+n00lNTQ3f//73OX369GXPyeVy/vEf/1H8jm9/+9usW7cuKBQdvLeQtLe3s3z5culEF8QIhcP1ej0pKSl0dXWRn58vLq7B+Lvl5+fjcDgICwvDYDCQmJhIYWHhTcnqdrt5+eWXOXr06BXlxP785z/z5z//GZVKxZo1a/j6178e8Hkl9M+zWCzk5OTMyzzAxcasxC5nZ2czMDDA4cOHefDBB/H5fMjl8qCcmFFRUfzlX/4lDz74IAqFAr1ef0NyqtVqNmzYQGlp6XX9JjKZDIPBEDSDf3BwkMbGRsxmMzExMSxbtkw60QU5sbGxlJeXc+jQIbKyssT5FIxotVpWrVpFQ0MDcrmc8PDwm573YWFh/P3f/z1f+tKXrpnnKXx2ZGTkLEj94bHZbFy8eJGhoSHCw8OpqKgI+kLUErOk6NLS0hgYGOAPf/gDAwMDjIyMiLUVgwmhwHFkZORNTxi5XI5arQ7aqNJrMTIywoULF9Dr9cTFxREfHx+UGxCJ/yE6OpqSkhLeeOMNhoaG6O/vJzExMSiDHoR6shkZGR/6M2Qy2WVNjoMZu93O+fPnUSgUxMTEkJiYKJku5wGzsk3Mzs6muLgYq9VKW1vbFd0BJOYev9+P3+8X+30lJSWRkpJCXFxc0J4OJN5DiFx0uVz09fVx8eJFvF5voMVa9Pj9fiYnJ6msrESj0ZCenk5CQsKCjdZeSMzKihcdHU16ejorVqzg7NmzvPnmm7PxsRIfkZGREWprazly5Ah33333VXuCSQQfGo2GlJQUli1bxuTkJL/73e+k0m1BwMTEBO3t7ezdu5eysjLWrVsXaJEkbpBZUXSCr2vTpk1MT0/T2NhIV1dXUEdgLnS8Xi8nTpygs7MTpVLJsmXLFkwz2YWOXC4nNDSUtWvXYjAYaGhooKOjA7PZHGjRFjUXLlzg/PnzyOVy8vPzyc3NDbRIEjfIrNmwNBoNd9xxh9jcs66uDpvNJtWBCwA+nw+3282BAwfo7u4mJiaGsrKyoPSbSlwdhULBxo0biY+Pp6Ojg/r6erGXoDSn5ha/34/H46GqqoozZ85gNBopLCwUy5JJBD+zpuhUKhUrVqxgw4YNJCQk8E//9E+0tbUFbQmjhczY2BjV1dXs2rULlUrFl770JXQ6XVAGM0hcHZlMRllZGbfddhurVq3i3/7t3zh8+DAulyvQoi06HA4HNTU1vP3227S2tvLVr36V9PT0oCy4LXF1Zk3RCTl1q1evZu3atQwPD3P8+HHOnDkzW18h8QEIbV6am5v54x//SFRUFPn5+SxfvnzBdU1f6Ag5dbm5udxzzz1YLBZqamo4ePCgFJgyh7jdbkZHR3n55ZfxeDxkZmZSUVEhFUefZ8x6+N3y5ctZvXo1AKdOneLEiRNSz6Y5QDBnmc1m6uvr2b17NxkZGRQVFZGfny9FWs5TMjIyuP3228XqIPv27cNut4utfCRuDYKJ2Gaz0dPTI1pHiouLWbJkiZQ7N8+Y9bN3VFQUpaWlfO973+PHP/4xnZ2dpKens2nTpgVf/y7QeDwevv/971NTU4PL5eI73/kOaWlpgRZL4iOgVqtJTU3lW9/6Fq+99hovvPACy5cvZ+XKlWRnZwdavAWN3+/nd7/7HQcOHMBms/H444+LdT0l5hezruhkMplYLWHNmjW0tbXx61//msjISPLz80lMTJztr5QAenp6ePfddzl9+jQGg4FPfepTJCYmolarJRPLPEYwYZaXl9Pf34/ZbObll1/G4XAgl8ulkm63CJvNxt69ezl27BjDw8M8/vjjFBQUEBkZKd3vecgt8aZGRESQk5PDqlWr8Hg8vP7662JTxujoaJRKpWRKmwUEc6XVaqWlpYU9e/YwNjZGQUEBO3bsIDIyUkpmXQAoFAoyMzNZtmwZo6OjPP/88yQkJGAymYiPjycsLEwKNJoFhPnkcDgYHBxk9+7ddHZ2EhERwb333ktKSkrQlPaTuDlk/lsYq+zxeKivr+eHP/whJ0+eJC8vj2984xssX7583pXSCkYEP8L//b//l6NHj7Jv3z6eeeYZVq5cSVlZmVhRXmJh4PV6sVgsfPWrX6WmpgabzcZ//Md/sGTJEuLj4wMt3rxHWApff/119u3bx69//Wueeuop7rjjDjZv3izNp3nMLVV0fr8fs9lMbW0tP//5zxkeHkaj0fCFL3yB/Px8MjMzb9VXL2iE1jtdXV3s27ePV199FYVCQW5uLl/4whdISkqS/KELEL/fj9vt5tSpU7z11lucOnUKrVbLPffcw6pVqyguLpYW4g+J1+vFZrPx6quvcujQITo6OigrK+O+++6jpKSEuLg46d7OY25pIohMJiMyMpK1a9dSU1PDyZMnqayspKioCI/Hg06nw2AwoFAopEF0g/h8PrxeL0NDQ9TX17N3716Gh4cpLCzkzjvvJCsrS4oIW6AIKTyrVq1ibGyMqakp/vznP2MymQgJCSEuLg69Xi82ApXm1AcjJIObzWZ6e3t5++236e7uRqFQcOedd1JUVCSdlhcAt/REB/9jDvD5fFy4cIHf/OY3vPDCC8THx7Njxw6+9KUvER0dLfkYbhCn08nw8DDf+c53OH/+PN3d3TzzzDOUl5dTVFQESAvcQubS+WQ2m/nhD3/IO++8w+DgIJ/73Od45JFHKCwslDaPN4jX66W/v58XX3yRXbt20dzczOc//3l27NjB6tWrJXPlAuGWKzr4n8k5NTVFd3c3r776Ks3NzbS2toqVHzZv3ozRaJQU3nVoaGigvr6e1157jb6+PmJjY9m2bRtbt27FZDKh1+sDLaLEHCGYMZubmzly5Ajnz5+nurqa0tJSioqK+PjHP05UVJR4upO4kt7eXlpbW3nuuefEjuYPP/wwK1asIDs7m6ioKEnJLRDmpIaNMFj0ej1FRUWMjY0RFhZGZ2cnVVVV+Hw+8bnIyEg0Go20k/pv3G63eIo7c+YMNTU1nDt3jtzcXIqLi9m2bRvJyclSdOUiQyaToVQqRTeAWq3mwoULNDY2YrFYyM3NJTs7G6PRKC7Y0nx67wTndrsZGBigoaGB8+fPc+7cOWJiYsjNzWXbtm3Ex8ej0+kCLarELDInJ7r3I/R16u3t5Stf+QptbW2YzWb+6q/+is2bN7Nu3TqUSqU0MYHh4WEaGxt55plnOHXqFEqlkrvuuouvfOUrZGRkiApOuleLF6H0W0dHhxiB29PTw8MPP8y6det47LHHCA0NlVJ6gMnJSQYHB/nud78rmv4fffRRHnzwQTZt2iSmD0jzaWEREEUH/3NSaWxs5MKFC5w6dYrq6mqioqJIS0vjgQceIC8vj9TU1EW3G52enmZsbIz9+/dz7Ngxuru7sdlsbNy4kYKCAlauXElqaioRERHS4iUBvOezczgcdHZ20tHRwZ49e2hoaMDtdpOTk8Mdd9xBfn4+xcXFyOXyRTWfXC4XNpuNt99+WzTxWq1WCgoKWLZsmViI3mAwLLp7s1gIWPnt0NBQQkJCWLp0KTqdDqVSSX9/PxaLhfr6emJiYpiYmGB8fJzExER0Oh0RERELVum53W5cLhcjIyP09/fT29vL8ePHaWtrw+VykZ+fz9q1aykoKJBKP0lcgVwuR61Wk5+fT2xsLHa7HbvdTldXFw0NDeh0OsbHx3G5XMTHx6PVatHr9Qt2PgkmypGREcbGxujr6+P48eN0dHQwMjJCUVERK1asYN26dRQUFEixAQucgJ3o3o/P52NoaIjDhw+ze/du3njjDbRaLUlJSTzxxBNUVFSQk5NzmS9qPk/Q9992i8XCwMAAv/vd79i/fz+tra2Eh4fzwAMPcNttt/Hggw8SEhIineAkbpjR0VGam5t57rnnxGLQ8fHxfPazn2XZsmWsWbPmMhfBQppPDoeD0dFRXnzxRU6ePMmRI0cIDw9n5cqVbN++nU9+8pOo1WpJwS0SgkbRCVFkk5OTTExMcPHiRc6dO8eFCxdoaWlBr9djMpnYsGEDy5YtIyMjg8TExHk5Of1+P16vl97eXjo6Oti/fz9NTU309fUxMzPDkiVLyMnJYevWrcTHxxMZGSkFFEjcNG63G4fDwcjICK2trbS1tXH06FHa2tqQy+UYjUY2bNhAfn4+paWlJCcnz9sea16vF7PZTFNTE0eOHKGtrY2GhgZmZmaIj49nyZIl3HHHHcTHxxMTE0NMTIxkplxEBM2oFqLIYmJiiI6ORq/XExERgVqtxu12MzU1xcjICKdPn2Zqaoq2tjYyMjKIiopCo9EQFRWFWq0Oyr5rQpK3xWLBarUyOTnJ8PAwPT09dHd309DQwOTkJKGhoWRnZ7NixQqWLFlCeXk5oaGh0q5T4kMRGhpKaGgoWq2WyMhITCYTHo8HmUzG+Pg4ZrOZc+fOMTo6yvDwMFlZWURGRqLT6YiJiSE8PDwogzOEjeLU1BR2u52JiQnGxsYYGRmhqamJixcvMjExAUBOTg45OTmsWLGCFStWoNFo5q0yl/jwBM2J7lp4vV7GxsY4ceIEZ86c4dVXX2V4eBi32016ejqrVq2ioKCA9evXk5WVhVarvaZiuJWT9Xq30eVyMT09zalTp6ivrxcbaE5NTeH3+1m1ahXr1q2jvLyczZs3S8pN4pbh9/uZmJigtbWVQ4cO8dprr9Hf38/4+DgZGRnk5eWxdOlSbr/9dlJSUoiPj7/uWLxVc+p688nr9WK326mrq6O1tZWjR49y4sQJhoeHsdvtlJeXU1xczO23386mTZvQ6XSSclvkBL2iE3Zvdrud6elpLBYL7e3t9PT0cO7cOdra2piYmMDhcKDX64mOjiY7O5vc3FxiY2NJSkoiJSUFnU53y3JjhNqT09PTjI6O0tPTI57YGhoaGBoaYmBgALvdjk6nw2g0UlJSQnZ2NhkZGaSnp6PVaomIiJByCCVuKcJ8EiIRzWYzQ0NDtLe3c/bsWXp7e+np6WF6ehqVSoVer2fJkiWkpKSQkJBAVlYWsbGxGAyGW5pQ7fP5xHy34eFh0d/Y0dHB4OAgHR0dTE9PExISQnx8PPn5+aSmplJcXExqaiparRatViv64aT5tLgJekV3KUK1/sHBQYaHh6mvr6elpYXh4WH6+vrEHl1CRJlarcZgMBAXFyf+n0ajEU064eHhYvRnaGgoMpkMuVwuTgyZTIbH4xG/1+Px4PV68Xg8OJ1OXC6X+HebzYbNZmNiYoLh4WHRRDk5OcnMzAwul4uoqChiY2NJTEykpKSEtLQ0EhMTiY6OliaixJwjjGsht6y2tpbe3l66u7vp7u7G4XDg8XjEeaNWqzEajURHR4sbtoiICJRKJUqlkvDwcEJCQlAqlWLg1KUPmUyG1+vF5/OJCld4OBwO3G43Ho8Hh8PB9PQ0DoeD4eFhJiYmmJqaYnx8HJvNhtVqpb+/n4GBAfR6PQ888ADl5eWkpaWRm5tLZGQkoaGhgb69EkHEvFJ012J6epqOjg7q6uro6uriwoUL1NbWMjY2xsTEBH6/n7CwMNRqNWlpaeh0OvR6vagANRoNWq2WkJAQQkJCiIiIEH1909PTonKbnp4WHyMjI1gsFqamphgdHaW3t1d8rUKhIDIyksTERMrLy0lPTycnJ4fy8nIiIyPRarWBvmUSEtfE6/XS0tJCR0cHbW1tnDlzhra2Nnp7exkeHsbn8yGTyTAYDMTHx2MwGIiOjsZoNIr+QLVaLSo8QQGGhoZit9tF5Wa325mZmRH7v1mtVqxWKwMDA4yMjGA2m/F4PMjlcsLDw8nIyKCgoACj0YjP52Pv3r1ERUXx85//nJycHKnJsMQ1WRCKTjBzCCcs4QTldDqZmpqiq6uL8fFxhoeHGRkZEc2gZrNZ3Dk6HA5Roc3MzOD1egHEppYKhYLw8HDCwsIICwtDr9ej1WpF845gzomPjyc1NRWVSiW+/tITpLC7lZAIVoQIaOExMzOD2+1menqac+fO8Z//+Z+cP39eTHkRToVWq5Xp6WmsViszMzN4PB48Hg8ul0tUbu+fT6GhoYSFhWEwGFCpVKhUKqKiojAYDBgMBlJTU4mLiyMyMlI8PSoUCnw+H9/5zneoq6vDYDDwgx/8gCVLlkhzS+KqLAgPrVwuFxXQpQhmRYPBgNVqZWJiQvTnORwOpqamcDqdOJ1OUbm5XC7a2tq4ePEiFouFnTt3imaYsLAw0UwjmHLCw8PRarVER0ej1WqJiooiJiZGnJASEvMNIQL6/fVT7XY7p06dIiwsjNjYWLZu3SqaI+12OzabDafTyfT0tDifhDnl8/nw+XwolUpxsxcWFiaaOoWCEOHh4ej1etGnbjKZxBOi4FIQTK4VFRX4fD4OHTpEfX09arWajIyMAN01iWBmQSi6axESEoJGo0Gj0dzwe5xOJ7t37+a//uu/aG5u5v/8n/8jFUyWWPQI9TTPnj2L2+0mMzOTBx98MCCBHoL/fOvWrahUKn7/+9/z7rvvolAoSEtLk4K5JK5AOudLSEh8IF6vF6vVyu7du4mNjeWOO+4IuJkwLi6OpUuX8sQTT3Ds2DF+//vf09PTg8vlCqhcEsGHpOgkJCQ+kNHRUdrb27FYLCQkJFBUVBTwk5NCoSA6OprNmzdjMBgYHx9n7969Yn6qhISApOgkJCQ+kL6+Purq6nC5XKSkpFBYWBhokYD3elxu3ryZrKwsXC4XL7/8MiMjI3g8nkCLJhFESIpOQkLiA6mpqWHfvn2sXbuW3NxcjEZjoEUC3vPXhYaG8uSTT/LAAw9QVVXFm2++SVVVVaBFkwgiJEUnISFxTXw+H1NTU/T29tLb20t5eTmxsbFBUxBZMJ+mpKRQUFDA0qVLOX36NKdOncJms+Hz+QItokQQICk6CQmJa+L3+8UeiaOjoyxfvjxoTnOXEhMTQ05ODuvXr6ehoYHTp08zPDwsmTAlAEnRSUhIXIeZmRlef/11+vr6MJlMrF+/nvj4+ECLdVXS09P52te+RkZGBl1dXXzve99jfHw80GJJBAGSopOQkLgqQu7cqVOnCAkJoaysjPDw8KAthKBQKNBoNGzbto2cnByqqqqoq6ujr68v0KJJBBhJ0UlISFwVj8eD3W6nvr4elUpFSUlJUHcCkMvlhIaGsnbtWvLy8ujr6+P8+fN0dnaKhaQlFicLujKKhITEh6enp4eamhr6+vrYuXMnd955Z8CTxG+EpUuX4na7aWho4Fe/+hUDAwMUFRWh0+mCVklL3FqCf9RKSEgEhO7ubqqqqkhNTRWLKwe7ohBabaWlpfHYY48RERFBe3s7b7zxBtPT04EWTyJASIpOQkLiMoRecQMDAzQ0NJCenk58fDx6vT7oFZ1AdHQ0q1evJiEhAavVyqFDh5icnJTKgy1SJEUnISFxBVNTUzQ1NXH69GnuuususrKyAi3STREaGorBYOCJJ54gLy+P1157jVOnTkmBKYsUyUcnISFxGR6Ph5MnT9LT04NSqaSioiJoUwquhXDyLC8vZ2JigpqaGl555RWsVitJSUmEhobOm9OpxEdHOtFJSEhchs/no66uDovFQnR0NCkpKeh0ukCLddPIZDISEhLIzc1l2bJl1NfX09DQwODgoFQxZZEhKToJCYnL8Hg8vP3223g8HjZu3IhWqyUkZP4af4qLi/nbv/1bPB4PVVVV/OY3v8HpdAZaLIk5RFJ0EhISImazmdbWVtrb24mKimLTpk1BnTt3I4SHhxMXF8fDDz9MZGQkf/zjH2lubmZiYiLQoknMEZKik5CQEDGbzbS3t+NyuYiKiiI7O3te5M5dj5CQEFQqFRUVFSQkJDAyMkJNTQ0DAwP4/X4pkXwRMH/tERISErOK3++ns7OTffv2ERMTQ3Z2Nvn5+YEWa1aQy+Vs374dq9XKhQsX+M///E9cLhf5+fnzXpFLfDDSLywhIYHf78ftdtPR0UFlZSWbNm0iNzc30GLNKjKZjBUrVvCVr3yF4eFhjh8/zq5du6QOB4sASdFJSEgAMDw8zODgIKOjoxQVFREfHy/2e5vvCNcRExNDcXExCQkJjI+P8+6772K1WnG73YEWUeIWIik6CQkJfD4fZ86cobW1Fbfbzdq1a0lPTw+0WLOOVqslNTWV+++/H6/Xy0svvURvby82m03y1y1gJEUnISGBz+fjnXfewWKxsHbtWkwmExEREYEW65YQGhrKxz/+cdavX09kZCT/+q//ysmTJwMtlsQtRFJ0EhKLHLfbjc1mo7W1Fb/fT1FRUVD3nfuoyGQyYmNjKSgoYNmyZVy4cIGmpiZ6e3sDLZrELUJSdBISixyHw8HQ0BBNTU0olUrWr19PaGhooMW6ZchkMkJCQlixYgWf+tSn6Orq4syZM5w8eRKv1yuZLxcgkqKTkFjkdHV1sWvXLsLDw8nOzmb16tXzuhLKjRIbG0tZWRmPPPIIg4ODPPvss4yMjDAzMxNo0SRmGUnRSUgsUoTgi7GxMWpqakhNTSUpKQm1Wr0gIi0/iJCQELRaLRs3biQ2NlaMwhwaGgq0aBKzjKToJCQWMV6vl8HBQU6dOkVpaSmZmZnzvuTXzaBUKrnnnnsoKipCoVDwyiuv0NLSgs/nk0yYC4iFb5+QkJC4JmfPnqW2tpaRkRG2bdtGYWFhoEWacyIiIrjzzjuJjo7m61//OmlpaURERLB27dpAiyYxS0gnOgmJRYrf76e+vp6RkRHi4uJISkpCr9cHWqw5RSaTIZfLSUpKori4mNTUVDo7Ozl06BBOpxOv1xtoESVmAUnRSUgsQvx+Pz6fj3PnzjE2NkZubi5xcXFotdpAixYQTCYTBQUFrFq1ir6+Pvbu3YvZbJYqpiwQJEUnIbEIcbvdmM1mKisrcTqdPPDAAws2QfxG0Wq1fOtb36K0tJSxsTF+8pOf0NTUFGixJGYByUcnIbEIMZvNXLhwAYfDgcFgoLS0dEHnzt0Icrkco9HIsmXLmJycpLKykqVLlxIbG0tcXNyiCdBZiEiKTkJiETIxMcHp06eB98x2+fn5iyJ37nrI5XJUKhXLli3D5XLx5ptv0tDQQEpKCnFxcfj9fknZzVMW98iWkFik9PX18ac//YmVK1eyfPlyVCpVoEUKGkpLS4mJieHtt9/m4MGDNDU1sWzZMpRK5YIti7bQkXx0EhKLCL/fz+DgID09PfT09FBSUkJWVtaCacczGygUCiIjI3nooYfQ6/X09PRw4MABxsfHAy2axIdEUnQSEouMvr4++vr6mJycJC8vj9TU1ECLFHSoVCq2bNlCQkIC09PTHDhwgKGhISkKc54imS4lJBYZ+/fvp76+nuzsbIqLi0lOTg60SEGHQqEgISGBBx54AKPRyE9/+lPy8vKIiIgQT8AS8wfpRCchsUjw+Xy4XC5qa2sxm82sXbsWlUolLdpXQTDlFhcXs379elJSUnj33XfZs2eP1KB1HiKd6CQkFglutxuLxUJXVxdhYWEsW7aMsLCwQIsV1CQlJeHxeCgsLKS9vR2fz8fHP/5x9Hr9ok/HmE9IJzoJiUXC2NgY+/btY2xsjJiYGO655x7UanWgxQpqZDIZCQkJfO9730OlUlFdXc0LL7zAyMhIoEWTuAkkRSchsUgYHx/n0KFDpKSkkJubi16vRy6XloDrIZPJCA0NJSkpiQ0bNpCfn89LL71Ec3MzZrM50OJJ3CDSKJeQWAQIJb8uXLhAUlISaWlphIeHS4ruBlAoFOh0OsrKysjLy6OlpYWmpiZ6enokf908QRrlEhILHL/fz+joKB0dHZw7d05MEpe4ObZt28bOnTtJSEjgpZde4ve//32gRZK4QSRFJyGxCKiqquLChQtER0dTVFRERkZGoEWadygUCpKTk/nKV76C0+nk7NmzHDx4EKvVGmjRJD4ASdFJSMxzPB4PDoeD/v5+rFYrbrdbNKcJf7a0tNDX10dKSgqxsbHodLpAijwvkcvl6PV6Vq1aRXR0NDabjePHjzM5OYnH4wm0eBLXQVJ0EhLzHLvdTm9vLy+//DJNTU1XnDC8Xi+nTp2ip6eH7du3o9frpdy5D4lKpaKgoIA77riD5ORknn32Wdra2rDZbIEWTeI6LMo8OofDgdls5oc//CFTU1P4fD7xOa/XS39/P+3t7UxNTfG5z33uCod9WFgYycnJfOITnyA9PX2uxZeQuAyHw0Fvby//8R//wYsvvii2mqmoqCAmJgafz0dvby8qlYrt27ej0+kkRfcRkMlk3HvvvURFRXH69GleffVVBgcHeeyxxwItmsQ1WJSKTpjkdXV1DA4O4nQ6xef8fj9OpxO73Y7H46GysvKK9wth2TMzM3Mms4TEtfB4PExPT9PZ2Ynf70etVmOz2bDb7RiNRuRyOVNTU0RFRREbG7vo2/HMBgkJCeTk5FBUVERzczM6nY4tW7YQFRV12f31er243W46OzsxGAzExMQgl8uljcYcsyhHfHh4OAaDAa/Xi9lsvm7yZ3d39xX/l5SURHJyMuHh4bdSTAmJG8Lj8YjFhv1+PzabjdOnT3Pq1ClkMpk43iMjI8X3vD8kXlp4b46wsDAyMzP567/+a770pS/hdDpZvXo1mzZtQqPRiK9zuVyYzWZ+9rOfsW7dOu66665F38k9ECxKRQfvRVBt3boVuVzO+Pg4Xq/3ht+r0+m4/fbbiYqKuoUSSkjcGB6PB5fLddn/CeNZsFAIyeL33nsvWVlZZGdns3r1atatW4dOp0OpVAZC9HmNwWBgzZo13H777bS0tPCDH/yA7Oxs0tPTCQsL49ixYxw9epR33nmH9vZ2ADIyMigtLZX62s0xi1bRyeVylixZwsWLF28q4VOj0WA0GklKSpLqBEoEBV6v97pRf0IxZ5fLxfj4OBaLhZGREWw2GzabjdzcXEpKSggLC5NOdjdBSEgIOp2OiooKPB4Pu3fvpqamhtHRUQDeeecdzpw5Q11dHQ6Hg6GhIXp7eykuLpYU3RyzqBXdypUrOX369A0rOplMRlxcHOnp6cTFxUmLgkRQ8EGKDrgs4GpoaIihoSGqqqp4/fXXeeihh/jOd75DdHS0tAB/CHbs2EFoaCh//vOf+eMf/4hcLmdycpLKykqcTicymYyQkBAmJiZoaWlh+/btgRZ50bFoFZ1MJiM2NpaMjAyWLFlCU1PTBy4WcrmciooK1q1bN0dSSkh8MILp8kY3bILSk8vlfP7zn2f9+vVERUVJ5cA+JBqNhrS0NDZv3szx48ex2Wx4PB4xWM3v9+PxeOjt7eXcuXM35SaRmB0WtaILCQkhLi6O/Px8Wltb8Xq9H7hYpKWlkZ2dPUdSSkh8MDdyons/BoOBjIwMVq5cSWZmphSJ+SEQol3PnTvH+fPn6e/vx2w2Mz09DVwe8OP3+7FYLPT29uLxePD7/ZJFaA5Z9KM7KSmJiooK9u7de4VD/2pkZ2dTUFAwB5JJSNwYN6vohFJW9913H2vXrpWCqm4CQXn5fD6mp6fp6+vjv/7rvzh//jzNzc3X3SibzWY6OztxuVz4fD7JTDyHLHpFl5mZSWhoKN/73veu+RqZTIZKpaK4uJjU1NTLwrQlJAKN2+1mZmYGuVx+XbOYTCZDLpezevVqtm7dylNPPYVWq51DSec/fr8fr9fLn/70J06ePMkf//hHpqammJmZ+UBrkHACbGpqIicnB5PJNEdSSyx6o3xERARGo5Hk5OTrVoyIiIigtLSUyMhIFAqFZHaQCBq8Xi9er/e6Y1ImkxEWFkZsbCy33347q1evlvrRfQiE3Nvz589z7tw5BgYGsNlsN2QNkslk+P1+enp6mJycnANpJQQW/YlOqVSi1WrJzc1lenoaq9V61Z1ZREQEK1eulMw8EkGHYLqUyWTiYvp+hJ5qWVlZ7Ny5k6ysLGmz9iFwu92MjY3R2NhIR0cHMpnshs3Gwv1ub28nKyvrVoop8T6k7RwQGhrKXXfdRU5OzlUXCblcLiaJS+YGiWBDiLq81ulMoVAQGRnJmjVreO6558jIyCA0NHSOpVwYREREkJOTw7PPPstPf/pTVq9ejVarvaFNg9/vZ2ZmhjNnzjA0NDQH0koISIqO9xaCoqIiYmNjr3AQX5o7p9frpeg0iaDj0mCU9y+4crkchULBHXfcwfbt24mPjyc0NFQ6zX1IhGjtmJgYioqKePzxx7njjjsoKir6wPcK/r2Ojg7MZrPUnXwOkVZt3lN0ubm5xMXFERYWdpkpQi6Xk5ycTE5ODuHh4ZJPQyLouNR0eSnCohwZGck999xDRUXFZXUYJT484eHhpKenk5aWhlKp5MiRI3R2duJwOK6bpuTxeOjp6cFiseD1eqXIyzlCWrX/G7VaTX5+PrfddttlpZD8fj9Lly5l8+bN0i5YIihxu91XDYaQyWTk5OTwi1/8gk2bNpGUlBQA6RY2MpmMBx98kG9+85v84he/IC0tjfDw8OtafqxWKwMDA3R1dUknujlCUnQgOvGTk5MpKyu77DmFQkFqaio5OTkBkk5C4vr4fL6rBkSsXr2a7du3U1JSgkajkawRs4ywbiiVSoxGI8uXL+ev//qv2blzJ7Gxsdc0EQuF5CVFN3dIpstLSEhIoLCwUIxck8vlaDQaEhMTSU5ODrR4EhJXRTBdCoumXC5HpVKxZs0aNmzYQGpqaoAlXPhoNBrUajWPPvoocXFxYp9Lm812Rd9KmUzGxMQE3d3dkqKbI6Qt3iVkZGSwZs0aNBoNISEhREREsG3bNlJTU6U2JhJBixB1KZzqYmJi+Mu//Es+9alPsXXr1gBLt7gwmUzs3LmT1157jccee+yaQSq9vb3U1NRcVmxb4taxKE90fr8fn8+HzWbD6XSKD6/Xy8TEBCkpKaI5KD4+HrPZTFNTE6GhoYSFhaFUKtFoNISHh0vOZImbQoi0s9vtzMzMMD09jdPpxOfzie10hL8rlUoxajIkJASlUinmfYaFhYkpAkIXa5/PR2pqKkVFRTz00EMkJCRI43MOEcyUISEhaLVaHn30UXJzc8nKymLXrl1i9RSfz8fg4CAtLS03VYhbqKxit9txuVzi53k8HjwejxjcIowX4c/w8HAiIiLEPxdjrMGCU3TCQuJyuUSTjtvtFgeC2+0W/99sNmOz2bDb7dhsNnw+H3a7HZVKRWhoqDiA2tvbsVgsKJVKVCoVERERGAwGNBoNoaGhKBQK8c+QkJDL/k9YjBbj4FpsCGNPGDfCuLv0IYy9yclJ7HY7U1NT2O120fQ4PT2N1+vF5/OJG6mQkBDCwsIICwsjIiKC6OhoVCqV+PzY2Bh2ux2FQkFSUhIFBQWUlJSgVCql4sEBQC6XI5fLWbVqFVFRUWg0GmpraxkeHsZqteJ2uzGbzfT39+N2u8XAFeFULqxTwuZFGDszMzNMTk5isVhwOp1MT0/j8/nEEnBer1dcf4RHSEgIGo0GrVaLRqNBp9OhUCiQy+Xi85euVcJ4g4W1Zsn8C8xI7PV6cblcXLx4kcHBQbq7u2lra2NkZIS+vj56enqwWq1YrdbL6gK+v9K48G/B4Sxw6d+VSiURERHExMSQkpKCyWQiJSWFzMxM4uPjSUtLIzMzE6VSuaAGjcTV8fl8zMzM0NnZycDAAC0tLfT09DA8PCz+39TUFGazGZ/PJ46xm+mHKBAaGopSqSQuLk5UqDMzMzz66KOsWLGCkpISUlJS0Gg00tgLIMLGp7q6mpdeeomXX36ZsbExfD4fsbGxHD16lJiYGGQyGfX19fT09DA0NER7ezs9PT2MjY3R39+PxWJhZmbmMlPnzY4boQycwWAgMjKS9PR0kpKSiI2NJTMzk8zMTGJjY0lPT7/sfQuBeavoBGU0ODjI6Ogozc3NdHd3MzY2Rm9vLxMTE+LpTa1Wi7th4RSmVCrR6XTikV6tVotKLSwsjPr6ekZGRli3bp1oSvJ4PDgcDmZmZrBarUxPT4smBMHp7HA4mJ6eRqFQEBERQVxcHEajkfj4eHJyckhKSiIpKQmDwSBFwc1ThLE3MTHByMgIFy9eZGBgQFRok5OTYj5VREQEYWFhqNVqVCoVSqWSsLAw0fStVquJiIgQ66eGhYWJJwLBKiHs2l0uF06nk8nJSZxOJzMzMzidTpqbmxkaGsLv96PX61GpVGg0GmJiYjAYDKSmporNgrOzs4mMjJQKH8whfr8fs9lMc3MzNTU1/N//+38ZGhrC4/HwyCOP4Ha7cTqdjI+PizVLNRrNZWPn0nGj0WgICwsjPDwcmUx2mUVJsBgIJ0Ov14vdbmd6ehqHwyHW5XS73dhsNnE9m56eJiIiArVaTUxMDKmpqcTExJCWlkZeXh4GgwGdThfoW/mhmVej3efziYrE4XBgtVppb29nYGCAhoYGuru7GR8fZ2hoSLRN63Q6DAYD0dHRxMbGkpiYiFarRavVEhUVhVqtRq1Wo9VqkcvlyGQywsPDSU1Npa+vjx07doi7MrfbLX632WxmcnISm83GxMQE/f39TExMMDg4iMViwW6343Q66erqwmAwEBcXx/DwMOnp6WRmZpKcnCyaQXU6HSEhIZLiC2L8fj8Oh0M0GU1NTTEwMCAGFQwMDDA6OkpfX5+48ERGRqLVaomOjhZ3zjqdjsjISCIjI8Vxp9FoRHPSpUpPMEcJwSZOpxOHw8HExARWqxW73c7o6ChhYWFERUUhk8kYGxvDarUyNDREV1cXarWa3t5e+vr6SEpKwmq1kpiYKCpenU4nLpISs49gVnQ6nWi1WtLT08U8O6fTSWVlpbhxCgkJQafTodVqxc1xVFQUcXFx4njR6/Xo9XoiIiJQqVTIZDJx4y4oOsHsKSg8q9WKzWYT16rJyUmmpqZEa8P4+DhjY2Oiog0NDaW3t5eYmBh6e3ux2WzExsYSGxuLVqsVN2ghISHz5tQ3r050TqeTc+fO8e6771JXV8fhw4cZHx8HIDExkZKSEtLS0igpKaGsrIzY2FiMRuOH+jEE09KHWQA8Hg8TExN0dXVx9uxZOjo6aG5u5vTp02L34cLCQkpKSigtLeX+++8nOjoatVp9098lMTf4fD6qq6upqanhzJkz7N+/n/Hxcaanp0lJSSEnJ4eMjAxWrFhBfn4+SUlJxMfHz8lCIPhylEql6GduaWnhwoULdHV1UVtbS01NDePj4zgcDvLz88nOzqaiooJ7771XXEglZp+BgQFaW1vZtWsXtbW1NDY2MjQ0RFhYGCqVipiYGO68804qKipYsWIFRqNRVGBzhbCR7+zspK+vj5qaGmpra+nq6qKurg673Y5OpyMzM5OtW7dSWlrKmjVrMJlM88YyENSKTjhBnThxgrq6OlpbW2lsbEShUBAeHk5ycjKZmZliLUqdTodKpUKr1aLX68Xj/odB2GW930d3I++D9xzLDoeDyclJpqensdlsjI2NiaeA1tZWRkdHmZqaEqvKZ2VlsX79etLT06UuCQHG6/UyMzPDqVOnaG5upq6ujosXL+L1elEqlaSmpopm6KysLLRaLSqVisjISNEseWmFnVuJ4LcRvsvr9WKz2bBarTgcDqamppiYmGB8fJzW1lY6OjoYGxtjZGQEnU5HQkICeXl5bNy4keTkZKmCyodEKNosWJiOHDlCT08P/f39hIaGEhUVhclkorCwEJPJhE6nY2hoiPz8fFJTU8U1a66Vh7DWCRHAU1NTTE1NMT09LUacDw0N0dvbS29vr2haLS8vJzc3l6KiIgoKCoK6UHjQqWOfz4fX6xWP00NDQxw7doympib6+vqw2+2kp6eTnJxMeXk5hYWFJCYmkpiYOKuLys0quEvfB4hRcsJOWdg1DQ0N0d3djVarpbm5mc7OTvr7+5mZmWF8fFysmpCUlITJZEKr1Yo5fPPFTDBfEUK/JyYmMJvNDA0NUVlZSVtbG83NzdjtdjHgqKKiguzsbNLT00lNTQ2o2fn93y3Ut7x07Hm9XiwWC2lpaVRXV9PZ2Ynb7WZwcFBUiiEhIWRlZTExMUF8fLzoPwRp7F0LYczMzMxgsVjo6emho6OD8+fPc+bMGTHKsqioiKysLLKzs1m5ciWxsbFoNBo6OzuJiYkJ6IlaWOsE/5/RaAT+Zy1OTk6mu7ubhoYGZmZmGB0dpaenB7lczsTEBBaLBbfbTVRUlDjuPuz6easIuhOdy+XCarXyyiuvsH//fk6cOMHU1BRFRUUUFRXx8MMPU1RURFxc3GXvC6abei3ef6u9Xi/T09McOHCAo0ePUl1dzcmTJ0lMTCQ7O5svfOELrF69msTERGB+XON8Rgg2+tOf/sS7777Lrl27sFqtJCUlsXTpUh555BEKCgqu6CU2H36X9489IcDl0KFDVFdXc+TIEU6cOIFWqyU1NZWnnnqK5cuXU1BQAMyPawwEgu+2vb2dAwcO8Nxzz4lVUTZv3kx5eTm33XYba9asueLEc2nvwGC8v1dTDW63m56eHs6ePcvLL79MU1MTra2t5OXlsX79em6//XbuvPPOoOuQERSKTjjtHDhwgFOnTlFVVcXQ0BCJiYmkp6ezbds2TCYTkZGRmEwmMQppvnPpTttisWA2m6mrq6Oqqoq2tjaGh4fJz8+noKCARx99lJSUFMmPN8sIZpvKykpqa2t5++23GR4eFs3Jt99+uxg5GxMTc9kpZz4jXLfFYsFqtYpjr76+nvPnzzM0NERSUhK5ubl89rOfJSkpSTKnX4LP52N0dJSTJ0/y+uuvi5HeRUVF5Obmsnz5cpKSktDpdOj1enQ63bwPNhPGjBB1Pjo6ysDAAO3t7ezZs4fR0VGmp6cpLy9n/fr1VFRUkJmZGRTXHVDTpVAhYmxsjL6+Po4cOSKGSsfHx1NUVERpaSlr165dMMrtUoQ2KkajEaPRiNvtxmAwoFAo0Gq1nDhxgv7+fpxOJyaTibKyMtFMO58inoIVIXqyq6uLY8eO0dzcTF9fn5hXtGrVKtauXYvBYCA8PDzQ4s4qgmkpKiqKqKgokpOT0ev1REZGEhoaSmVlJRaLhZqaGg4dOkRBQYFopl3MEcJCdZKuri7a29s5cuQIbW1toolv5cqVFBYWsnz5ctRq9YK6T8KYiYiIICIiApPJRGJiIklJSUxMTNDY2EhbWxsNDQ0olUqcTicul4u4uDj0er0YTRwQ2QNxors0UbahoYF9+/bx0ksvcfHiRcrKyti0aRN/9Vd/hcFgWBC75w+Dw+GgqamJX/3qV5w8eZLz589z1113cdttt/EXf/EXaLXagA6c+cqlw72trY3q6mp+8pOf0NLSgslk4t577+Vzn/scSUlJi7Z3m9frpaGhgT179vDWW29x+vRpVqxYwZo1a/jqV7+KTqdbVEUQLh0zdrud5uZmnnnmGc6dO0dHRwePPvoot912Gzt37hQX9MWIkOj+T//0TzQ2NjI+Ps4jjzzCgw8+SEVFhZiHF4hxM+eKTvi69vZ2jh07xi9/+UtmZmbQarU8/vjjZGVlkZaWRkxMjJhbtBjx+Xw4nU6xMsLBgwc5cOAAFouF+Ph4nnzySQoLC8UqBhI3ht/vZ3x8nN27d/Paa6/R39+PRqPhYx/7GPn5+eTl5WE0Ghd1bpnf78fpdGKxWBgdHWXPnj2cOnWKtrY2kpKSeOihh1izZg25ubmLQtkJa9bBgwc5ffo0L730EhqNhoyMDO6//36KioqIjo4mMjJyUW8+hZzBwcFBampqqKmp4Y033hCLFnz1q18lLS0Ng8Ew57LNqelSqC5y4cIF6urqOHLkCG63m6SkJEpLS8VoJCmn539arSQnJxMZGSkG6TQ3N9PR0cHRo0fF6i+pqakfOo1iseD3+3G73bS2ttLa2sqhQ4eYnJwkKiqKVatWsWrVKrEaxGJHME+Fh4cTHR3N1NQU8F4kcVNTE6dOncLhcCCTyUhISECr1QZY4luHx+PBZrNRX18vulYUCgVlZWUUFxezYsUK4uLiFpxb5cMg1M7MyspCoVCg0Wjo6+uju7ubzs5O9u7dy8qVK8nKyiIlJWVuNwT+OcLn8/mdTqd/ZGTE/5nPfMZfXFzsj4iI8H/zm9/079+/3+/z+fw+n2+uxJmXWCwWf2Vlpf/uu+/2G41Gf1FRkf+HP/yhf3h4WLx/0j28Ep/P53e73f6xsTH/t771Lf+qVav8YWFh/i984Qv+l156SbpvN4DVavU3Nzf777//fn9aWpo/Li7O/y//8i/+ixcv+r1e74K7h8L1TE1N+aurq/233367Py4uzp+VleX/13/9V39PT8+Cut5bgdfr9Y+Ojvp//OMf+zdv3uxXKpX+xx57zP/cc8/5PR7PnI6ZOTFd+v/bXHT69GmeffZZuru7KSws5OGHH6aiooLIyEhUKhUQnGG2wYKQxDw+Ps4f/vAHzp49y6FDh/jYxz7GunXruO+++8QyZhL/g8ViobOzk6effpr+/n70ej1f/OIXKS0tFXMVQRp710OwxgwPD3Po0CGqqqp444032LJlC6tXr+bzn//8ghp7Ho+H0dFRfv7zn1NZWUl3dzePP/44K1asYOnSpWLZvoVyvbcC/39HlU9OTjI4OMjvf/97jhw5wuTkJA899BCPPPIIOTk5c5Jzd8tNl0KU0uHDhzl79ix9fX0sX76c8vJyli5dislkCuqM+mBCKBSdlJRERUUFSqWS4eFhLl68KEbQrVy5ctH2nHo/Qs/BM2fOUF1dTU9PD7m5uSxZsoSlS5cSHx+/aIOdbhahrYuQU6hUKmltbWVwcJDjx4+Tk5NDcXExUVFR896vLtQT3b17N7W1tdhsNjZv3szKlSspKCgQ64pKXB8hqjwqKorw8HDWr1/P1NQUTU1NnDhxgoSEBGw2G0uXLhVff6u4pYrO/99O7f7+fn7+85/T1dVFZGQkTz75JLm5uQFxSs53hMGwatUq0tPTSUxM5Bvf+Abd3d0MDAyQlZVFXFzcguwpdTP4/zs3c2BggFdeeYUDBw4QFRXFww8/zPr168XWKBI3jnC/ioqKSE9PR61W82//9m8cPnwYh8PB3//934tFoi99/XxBMG5ZLBaampr4/ve/j1qtJi8vj29/+9sYjcYFl2YyF8hkMtRqNdu2bcNoNHLq1Cm++c1v4nQ6aW9vp7Cw8JZXf7qlpkuz2czZs2f59re/jcfjYdmyZfzt3/4tycnJhIWFLdqottlCMGVWVlZy8OBBnn/+eR544AG2bt3Kzp07gfm32MwWVquVnp4evvCFLzAzM0NcXBw/+tGPSEhIQKPRLCgzWyAQooKFUlf/9E//xNatW1m7di1PPvkkMP/GnlB68Kc//Sn79u3D4/Hw1FNPsX79epKTkxd1ROVsIZRKO378OD/96U8ZHBzk7rvv5oknniAzM/OW3d9bcqITdtPHjh2jqqqK8fFx7rrrLioqKkhOTiY8PHzemzeCAcGUmZ+fL7YsunjxIlqtluTkZEpLSxddNJgw9mpqajh16hRjY2NiZfiUlBSxK7fER0OICs7MzMTn87FhwwaGh4c5efIky5YtY8mSJfMqGlMohL1r1y4aGhpwu93ce++9lJSUEB8fLym5WUKo/yt0QKirq+PkyZOUlZXhdrvJz8+/Jd97SxSdMGhef/11ampq0Gg0PPTQQxQVFYlBJxKzg0wmIyUlhZCQEFQqFU899RRutxuVSkVOTs6iq2Lh/+9qO4cPH+YPf/gD4eHhbN26lTvvvHPO258sBuLi4lCpVHz+85/ne9/7HlVVVaSkpIil+ubL2HO5XIyMjPDzn/8cj8dDYmIiTzzxBHq9XkrdmWXCwsLIzMxk586dxMbG8o1vfIN9+/bhdDrJycm5JdaWW6Lo+vv7efbZZ6muriYhIYF//dd/JSsrS3L830JiY2PZuHEjX//61zl06BD//u//zvLlyykqKiItLS3Q4s0Z09PT/OhHP+L48eN4PB5+97vfkZaWhl6vD7RoCxaNRsOGDRuYmpri+PHjPPvss6SlpbF27VqxKHSwc+DAAfbu3Utvby9/8zd/I/aInC+Kej5SVFSE0WhkZmaG3/zmN3R2dpKXl0dJScmsVyWadUU3MDDAxYsXqaysJDc3l9LSUlJSUggLC5MGzS1E6NG3cuVKzGYzDQ0N7N27F4/HQ1xc3Jz1Rgsk4+PjdHV1cfz4cXQ6HSUlJaSmpoo+OYlbg1wuJywsjOLiYlwul9h1xOfzkZGRgVKpDNr77/V66ezs5Ny5c9TW1rJlyxZKSkpITEyU/Li3GKFH37p16zhx4gSjo6P84Q9/EBPwZ9PtMmuKzn9Jaa/z589TW1vLfffdx4YNG+YsutLr9eLxeLDb7Vc8J5PJkMvlaLXaKyad/7+rcjudTpxO5xXvFdrGC+3phT5NAnK5HIVCgUKhEEtHBaSem0xGSUkJ4+Pj1NfX8/bbbxMZGcnq1asXdJShMPYGBgbEBevRRx9lx44dcxbuLowJm812RXsTYeypVKorUmmE17pcrquO2/DwcCIiIrDZbHi9XrHJ6rUIDQ0lNDQ0IBsboSRYeXk5Z8+eZXp6mnvvvRej0RiUik7w59bW1nL+/Hk6Ozv527/9WwoLC8W6jLf6+71er1j8+P3I5XJCQkKueroR1iyr1XrZWgT/U9nG7XbjdrtvWJ6QkBDRBTJXaDQaVqxYQXl5OSdOnOC1117jnnvuISoqalYV3axFXfr/u8TSl7/8Zc6cOUN6ejrf+ta3WLJkyZx1zO3o6ODYsWP8zd/8zRXPaTQa4uPj2bVrl9jf7VLZp6am+MEPfsDPfvazK977f/7P/2HLli0cOHCAkydP0tHRQVtbGy6XS+w+kJeXR1FREffccw/Z2dkBDUO22+0MDw9z9913k5iYyPr16/m7v/u7BWs6Fsbez372M55//nlycnL49Kc/zbZt2+YsqVewZDzyyCNXLC5KpZLExER+9rOfsXr16itkt9lsvPHGGzz11FNXfO5TTz3Ft771LT71qU9x8eJF+vv7ryvH7bffzm233cYXv/jFgGxsXC4XY2NjfOYzn2F8fJw777yTJ598kvj4+DmX5YMQoizvvvtutFot2dnZ/OQnP5mzYDm3201zczM/+MEPePPNN694PjY2llWrVvHrX//6it/S7XZjtVrZsmUL7e3tlz2nVCp5+umnOXnyJHv37r1heUpLS1m9ejXf//7353zsjI2NUVlZyRe+8AV27tzJunXreOyxx2bt82dNA01PT3P27Fk6Ozvx+/3s2LGD2NjYOW0LbzAYKC0t5Zvf/CaHDh0SFZKQ6Ll69epr7tTCw8PZsmUL4eHh/PGPf0Sv1xMTE8OKFSvweDz8+c9/Zvfu3cTFxVFcXMzGjRtRKBR4vV7sdjv19fW8++67tLe386lPfYrMzEySkpLm7NovJSwsDKPRyLp16+jt7eXYsWN8+tOfxmg0Lkhl5/V6OXPmDM3NzVitVrZv305WVtacFiLQarVkZGTw9a9/naqqKpqbm7lw4QKFhYXk5uaydetWkpOTr/pepVJJSUkJ3/jGN3jjjTfw+/3ExMSwcuVK1q5di9/vZ3p6GpvNJtadvBbT09PMzMzciku8IYQE4YqKCurq6jh8+DD33XcfWq026LpB9Pb2Ul9fz9DQEMXFxdx+++1z6mKRy+WYTCYeeOABMjIyeOedd8QNdHl5OevWraOsrOya742IiOCv/uqvOH36NCdOnCAxMZHU1FSys7MJDQ0V21DdKCqVKmB1hnU6HampqWzevJnm5ma0Wi3bt29Hp9PNSpT0rGghIdLt+PHjjI+Po9Vq2bhx45wnhBsMBgwGAyUlJcjlco4ePUpbWxt5eXls3rz5mjsEmUxGWFgYGzdupLS0lHPnzpGdnU1hYSGf/OQnef755zl69CgnTpzg8ccfZ82aNaxbt46IiAgx6bGrq4va2lreeecdsahpoBSdYH5Yt24db775JocOHWJgYEDsI7WQEMxPp06doqenB4VCwbp1667oQH+r0Wq1aLVavvrVr/LCCy/wzjvvUF9fT1paGqtXr+Yv//Ivr/o+YewVFRWRn59Pc3MzISEhlJWV8alPfQqNRiOaNFUqFUaj8bqnVIPBEFCFIpfLCQ8PZ8WKFdjtdvbv309vby+xsbFBo+gEI1Zvby+nTp3C4/GQmZnJ6tWr59TEqlAoMJlM3H///axdu5bJyUnMZjNms5nS0lKxo8bVfmvBJ/+5z32OlJQU+vv72bBhAxUVFaxatYoXX3yRkJAQIiIi0Ov11xwvXq8Xt9uN2WwmISHhmpuxW41SqSQ2NpbNmzfz4x//mMbGRgYHB1GpVLOi6GblV/X7/UxMTPD888+TkZHBPffcQ3x8fEBzuDZv3iyaifbv38+ZM2eu2hr+UqanpxkeHub48eOYTCa2bdsmDnydTseDDz7IJz/5Se677z5iYmLQaDQYjUbKy8v59re/zWc/+1m8Xi/PPffcVU0Rc4lCoeD+++9n1apVaDQaXn31VS5cuBBQmW4VMzMzvPDCC/j9fj72sY+RlJQU0E7s5eXlbNu2DZlMRlVVFYcOHfpA39rMzAxjY2OcPn0aj8fDjh07rtiUPProo7z11lu0tbXR3t5+1ccvf/lLPv/5z9/Ky7shtmzZwtatW4mOjubtt9/m2LFjgRbpMvx+P+fOneMPf/gD999/v9g5JVBoNBoeeOABkpOTmZyc5PXXX2dwcFD0xV0Li8VCe3s7J06cYMOGDRQXF4vPpaenc++991JfX3/N8VJVVcUvf/lLwsLCWL9+PVu2bJmLy70qcXFxPPbYY6Snp2M2m3nhhReYnJyclc+elRPdwMAAra2tjIyMkJ2dzdKlS+ekUOf1SElJIT09nZiYGKxWK/39/TQ1NZGVlXVNBdzT00NNTQ2ZmZkkJCSIx/g1a9aQlZWFTCYTOyxfilwuJyEhgfj4eEJDQxkbG8NisYgDNFD3QalUkpqayrJly6iurqa4uBiv17ugosnGx8fp6OhgeHiY4uJiVq9eHfBiu3FxcWRlZWEymXA4HAwNDdHU1CRGgF6N8fFxzpw5Q1xcHCkpKVetp6hQKAgLC5sXSe9KpRKTycTq1atpbW3FZDIFzdjz+Xy0tbXR3d3N5OQka9asITk5OaByhYaGkpOTQ2JiInq9nrGxMTo6OsjIyLhuelBNTQ2jo6Pk5ORgNBrFXFGj0UhKSgpqtRq1Wn3NmIH29naam5vFSNO5CMK5FkL0bmlpKY2NjZw4cYK/+Iu/mJVgplk50Q0ODtLR0SH2RsvKypqNj/3QCD90fHw8SUlJuN1uRkZGaGpqum4UUn9/Pw0NDWRnZxMbGysWR87Pz2fDhg2sX78eo9F41ffqdDoxonNmZuaqUVRziUwmQ6FQEB8fT0lJCW1tbQwMDDA9PR1QuWabiYkJWlpamJmZwWQysWTJkoBH+On1enHsyWQyJiYmaGxsvGpUpcDExATnzp0jKSmJpKQkVCpVwK/joyCXyzEYDCxfvpyhoSG6u7ux2+0feLKdC/x+v7gx9/v9FBYWBrwPYUhICHFxcSQmJmI0GrHb7XR2dtLV1XXN9/j9fhoaGrBYLOTl5V3W+d1kMpGWlkZ2dvZVx5Hf78fn89Ha2kpLSwslJSXExMQQHh4eMIUvRCcvWbIEk8nExYsXsVgss+JznpWZVFNTw5kzZygtLSU3N5fExMSA79oA4uPjuf/++9FqtfT09PCnP/3pugt9fX09Bw8e5O677yYjI+OmvmtmZgaHw8HMzAwpKSlz7iO6Fjk5Odxzzz3YbDZaW1s5d+5cUCw2s0VHRwcHDx4kLy+P/Px8UlNTg2LsaTQa7rvvPhISErBYLLz++usMDw9f8/V9fX288cYbrFmzRqzmPt+JjY0Va652d3dTVVV11fSducbj8bB//36mpqYoKSkhMzMzaAoKlJeXs3nzZgBOnDjB0aNHr/lav9/Pvn37GB0d5b777hPTAuRyOcuXL+eee+7h4x//+FWDsoS4ipMnT1JdXc2jjz56RTR6oNi4cSNLly5lfHyc8+fPXxFV+mGYFdNlf38/AwMDFBUVodPpgmKhAcTIw1/96leMj49z9uxZLBYLer3+MvOl1+ulu7ubwcFBpqenKSsru+kdXkNDAy0tLcB7/sHly5cHxX1QqVSYTCZiY2OZnp6mtbWV1atXB73p60YZHx8XA45iY2OD4p4DREREsG7dOvbv309HRwdnzpxhZGQEp9N5mRnJ7/fT19dHb28vk5OTorK+Gj09PRw6dIhXX32VqakppqenkcvlREVFYTKZWLVqFbm5ude0Osw1gvlS8H01NzdTXl4eYKneM122tLQQFhZGQUFBUNWxzM/PZ3JyErlcTmtrK0ajkenp6SvM1TabjYGBAcbHx4mPjxdbJwE35DZyOBwcO3aM6elpTCYTBQUFQRMsJIzn2NhYenp6SElJobCw8CN95kdSdELC4/j4OGazmYyMjKCqZalWq8nJycFgMDA6OkpPTw8jIyNERUURHR0tvs7n89HR0YHNZkOlUpGYmHjDwQxConB9fT1dXV1ERUWxbNkysrOzb9Vl3RRKpRK1Wo3JZMLtdtPX1/eBQTnzAWHsTU1NMTg4yJYtWwIWGn01lEolOTk5xMTEEBISQk9PD0NDQ1gslitO+z09PYyOjhIREUFCQsI1o5UnJiZobW2lt7eXqakp7HY7fr8flUqFwWDA4/Egl8vx+/0YjcaAL94hISGo1WpiYmKwWCx0d3ffVALzrcDn8+F2uxkcHCQzM5O0tLSA36dLiY+PJz09HY1Gw8TEBH19fYyOjhIXF3eFomtra0MmkxEZGUliYuINb179fj8zMzOcPXsWgKSkJEwmU1DcByHZXa/XYzKZGBkZYXx8/CN/7kcyXfp8PiwWiziBi4uLg8YEAO/lk8XGxrJs2TLS09OZmZnh8OHDXLx48bLXud1udu/ejVwuZ+vWrTdVVcLj8TA+Ps4LL7xAdXU1O3fuZPv27RQVFd2KS/pQKBQKioqKRJv+QjFdTk1NMTIywtDQEAUFBQGNmns/Quh4UVERS5YsweVycfr0aU6dOnXFaw8fPszAwAB33nknOp3umr65mZkZfD4f3/rWt3jhhRc4ePAgv//978XO8t/85jf53ve+x/PPP3+rL++myMnJQa/XU1dXF9AcP3jvHprNZvr6+ggPD6ewsDCorBt6vZ7k5GQqKirQaDSMjo6yd+9eJiYmLnvdwMAAf/7zn1m+fDmlpaU3na9stVp55ZVXSEhI4I477pjNS5gV9Ho9JSUldHV10dPT85E/7yMpOq/Xy+joKA6Hg5CQEBITE4OqMaFwhK+oqGDJkiX4fD7effddmpqaxNd4vV6mp6c5ceKE2AX3Rk0Z09PTNDQ08N3vfld875NPPhl0HYjlcjnx8fHIZDLGxsYWzIlubGwMq9WKTCYjPj4+oBFj70cYe8XFxaxcuRKAc+fOUV1dLb7G5/OJO2uz2cyWLVuu2mEhLCyM73znOzz99NM8+eST5OXlERMTg1qtJikpifvvv5+//Mu/JCcnh+bmZvbv309LS8t1g1/mEpPJhEqlYmRk5IpyVXPN9PQ0Y2NjeL1etFqtOC+CBZlMhlarZcuWLRiNRiwWCwcOHMBisQDvjXuXy8XQ0BCVlZWUlpayZMmSm4py7+7upra2lomJCbKzs4PCnPx+BOvG5OTkTSW9X4uPZLr0+XxMTU3hdrtRKBRERkbOaTWKGyU3N5fW1lYUCgVtbW309/fjcDgIDw8XB/74+DgajeaGmv8JEUvt7e3U1tZSV1fHsmXLWL58OcXFxUEXLSeTyUQlYLVaF4Sig/fMN8IJIVjbqaSlpZGTk4NCoaCvr4/Ozk6mp6cJCwvD7XaLY0+tVpObm3vV+RMSEiIqy/cTGhqKRqMRW59UV1fT2dlJR0cHUVFRAc0nFNBqtSiVSqampgJuTXC5XOIcCA8Pv24ydaCIiIiguLiYyMhI+vr6aGxsxGw2MzMzg1KpxGKxMDY2xsTEBKmpqTddXq2/v5/W1lY0Gg1xcXEkJCTcoiv58ISGhhIZGYnD4ZiVAKaPbLqcnJzE7XYjl8vR6/VzWvLrRikvL6ewsBC1Wk1HRwctLS10dnaKQSgnTpwQw3HT0tI+UFEJ3ZWfffZZfvWrX5Gens4Xv/hFHnvssaBTcgKCopuN3VEwINQndTgcoiIPJmuCQEFBAeXl5Wi1WjGXs7Ozk5mZGcbHxzly5AhqtZqUlBQyMjI+9EZRpVKxceNGTCYTNpuN48ePYzabZ/lqPhwajYbQ0FAmJycDruhmZmaYnJwUFV0wBc8JqNVq1q9fL0ZBNjY20tbWxuDgIABnz56lo6ODpKQkMjIybjpwrrq6msOHD7Nt2zbS0tKCsrNJaGgoOp2O6enpWUmJ+kirsuDU9Hq9YimjYFzoQ0NDSUpKYuPGjYSHh9Pd3c2+ffuYmZmhvb2dw4cPs3HjRjIyMj7wB/d6vfT29vLd736X8fFxiouL+frXv35ZW49gGzSCgxcIuI9kNnG5XKIpTKlUBpWvRUCo/bhp0yaioqKYmJhgz549mM1m0f9SUlJCWVnZRxo7CoVCrPju9XqxWCx4PJ5ZvpoPR1hYGAqFAqfTGXBF5/V6mZmZwe/3o1AoAlq96VrIZDJCQ0MpLS1l2bJlAFRVVXHmzBngvbSDgYEBtm/fjlqtvuEx4/V66evro6GhgY6ODu65556gSQV7P0Itz5vtwHDNz5sNgYQbFWj7+9UQkhCjoqIoKSlBqVQyOjpKTU0NVquVoaEhOjo6bjiYQRgoFy5cIDExkbKyMgoKCkTfit/v5/z58zQ0NATFDlZAkCMYNyIflkvHns/nC0qTrFwuR61WU1JSglarxWazcf78eSYmJhgfH6e5uZm0tLRrphQsBITfJhiqogjrAfyPCyLYEIo9ZGZmitHbLS0ttLS04HA46OjowG63U1paelNWDI/HQ2trKxaLhZCQELKzs4PKr/1+fD7frB0cPtKqJ/R3Cw0NxefzYbPZgmYX+X4SEhK4/fbbiYiIoK+vj0OHDtHd3U1nZyft7e2sWbPmuouNUHPuz3/+My+99BJut5uPf/zjfPKTn7wseMXv9/PNb36TH/3oRzQ1NQW8Qoogk9VqBQiaXJnZQK1Wi345u90eFPf6auh0Ou64447LgguEElQXL16kuLiYJUuWXPW9wri7Xs3DS9N8XC6X6C8PFjeC3W7H4/FctRfkXKNUKtFoNMhkMlwu11X7BwYLS5cuFX2z1dXVnDp1iv7+fpqbm5mZmWHjxo03nM7l9/txOBzs2rULl8tFYWEhaWlpQeHDvRput5upqalZK0T/kRWdTqcjNDQUr9eL2WwOeJ7MtdDr9RQUFJCRkYFGo2FkZIQf/OAHNDc3s2bNGgwGw3XNGGazmeeee46qqioUCgU//vGPyc/PD5rF5Hr4/X4xaisYfRIfBiE6LTw8XLy+YKi6cTXCw8MpKCggKyuLmJgYzGYz//Ef/8GePXtYv349JpPpmpO5vb2dP/7xj/zFX/wFb7zxxjW/w263c+DAAYaHh9FoNNx2221ERUXdoiu6OaxWKy6XC71eHxSKTpDD4XDMWtHgW0Fqaip5eXmkp6fjdrs5f/48//t//2/i4uJEC8GN3k+Xy4XZbObtt98mJiaG7du3B/U64Ha7sVgsqFSqWVF0H2mVlsvlREZGEhYWht/vZ3x8PKhymS5FiE7LyspiYmKCsbExamtrKSgoYNmyZSiVymsOGqHA6qFDh2hra0Or1dLU1ERHR8dVu5UPDw8HVT6h8Nv4/f6gSqr+qOh0OtFkPDExQXx8/GWFAIIFhUKBRqMhNTWVpKQkBgYGaGxsJC0tjTVr1qDRaK7pXxQ6alRVVREXF0d2djYpKSmi30soGt3Y2EhHRwcajYaMjAzS09ODpiWTEDEYFRUVcD9qWFgYer1e9BmOj4+Tnp4eUJmuRXh4OFFRUeTm5mKxWDCbzVRXV7Nx40bS0tJuapM9MTFBV1cXFosFk8l0zfY/wYLQwFej0czKqfMjKbqQkBDi4+PRarX4/X46OjpITU0Nmp3k+5HJZKxevZrJyUkaGxvp7Oxk5cqVrF+//rqD5uLFixw7doxXXnlFNHMcPnz4ut9lMplmVfYPi+CHEIrDJicnB3xXPRvIZDJiY2NFE113d3dA+2ndCKWlpZjNZk6fPk1fXx8JCQls2rTpuuZkwe/b3d3NgQMHcDqdfPaznxUL8A4MDPDmm29SWVlJR0cH27ZtY8OGDeTk5AR8IRPmSl9fH1ar9aqdP+YatVpNXFwcYWFhTE1N0d3dzdKlSwOugK+FXq9n06ZNNDc309nZSWtrK3/zN39zWTue6yH8Bq2trRw/fhylUkl2djalpaW3UOqPht/vx2az0dHRQUxMzKyUtPvIo06IaIyPj6e2tlaMEgpG5HI5mzdvpr+/n7feekvcLZWXl193Al64cIETJ04ErS3/g/B4PNTX11NQUBAU1f1ni9DQUEwmE5mZmVy8ePGmC3HPNRUVFbhcLv7rv/6LyMhI0tPTqaiouK6fJSMjA4PBgFwuF/16X/rSl7DZbDidTtGEGx0dzb/8y7+wfv16MjMz5/Cqro/f76elpQWXy8WaNWsCnusoNCzNycnB6/Vy4cIFduzYEZT5v/Be3cd77rmHP/zhDwwNDaHX61m6dCk5OTk39Tk1NTW888477NixQ2wMHYwIa+zk5CQXLlzgscceIyUl5SN/7kdSdEJEjMlkwmg00tLScplzN9A7yqsRExNDeXk5n/jEJ9DpdCxfvvwDj8YZGRmsWbPmpnYWRUVFGI3GgA+o6elpRkZGRHt3SkpKUP4uN4sw9oSSSZ2dnYyPj89qpNZsYzAYyMvL45Of/CQajYaioiIxMOJaREREoFAoqKioIDY2luTkZAYHB8Vk+ZCQEIxGIzExMaxYsYKsrKygMd+6XC4mJiYwm81oNBrS09MDrlCEqMvU1FSxaanX68Xv9wflmAkNDSUuLo67776b4uJiNBrNh6pAlZGRwfr16ykrKyMhISEor1VgYmKC0dFRLBYL8fHxs9JCaVbsCEIPrTfeeAOz2YzX6w34An81hMTiu+++m7vvvvuG37d9+3a2b99+CyW7dYyNjdHU1ITNZsNgMJCbm7tgTnTwXoeK3NxcXn31VQYGBvD5fEE59uC9iNdly5bdVC1KuVxOeHg4S5cunXfte2w2G42NjVgsFoxGIwUFBUGRtyaXy8nLy+PEiRNcuHABt9sdtIouJCSEyMhIvv3tb3+o9wvXdLNrXiDp7Oyku7ub6elpsQn2R2VWVrwVK1awceNGhoeHOX/+PHV1dbPxsRKzQHNzM2+++SbZ2dnk5+ffUFL8fELot2exWGhsbKSqqiooc6MWI0NDQ/zhD38gJiaGgoICsrOzg0LRhYSEcM8995CSksLAwAAnT56kv78/0GJJ/DcHDhygoaGB4uJicnNzZ6W356woOoPBQEJCArGxsXR1dVFfXz8bHyvxERAaK/b19XHx4kUKCgpISEgQOxAvFDQajTj2JiYmqK6uDsrCBYsNwWReU1NDamoqmZmZQTP25HI5cXFxxMfHYzAYOHPmjFheSyJweDwebDYbTU1NmM1mSktL0Wg0sxLANCuKTqvVEhsbS35+Pu3t7Zw+fTpoK1UsFoSUgo6ODhobG1m5cuWsOHWDDZVKRUxMDLm5uUxOTnL06FHcbrd0qgswFouF3t5eamtryc/PJy8vL9AiichkMqKjo0lJSSEtLY1jx46JtW+lNStwuN1uRkdHaWhowGq1ctttt81af9NZc9YYjUa+/OUv43Q6qayspLKyUkxSlph7PB4P//mf/8nZs2eJi4tjx44dQbXYzCZKpZInn3ySuLg4cewNDAwEWqxFzSuvvMJbb72F0Whk27Zt1+y+EEgqKir4/Oc/z9mzZ6msrOT06dOSogsgPT09/OQnP2FmZoa8vDx27tyJVqudlc+eNUUXFhZGfn4+6enphIeHs2fPHkZHRyUzUgCw2+309/eLRWDXrVtHZGRkUPhHbgUKhYKcnByysrIwmUzs37+fjo4OPB6PtHDNMTMzM/T393Pu3DlGR0fFjgrB2FnCaDSSl5dHamoqAwMDHDx4EJfLJVkDAsDo6Cjt7e2cOnWK/Px8ysrK0Gg0sxY4N2uKTqlUkp6eTlFRESaTibfeeove3t5ZabEgcWMI9RDNZjNNTU3U19ejVqvZtm0b4eHhCyra8lKEcPH8/Hxyc3N55513aGpqCprGo4sFoZ5iU1MTDQ0N2O127rrrLgwGQ1BGwhoMBjIyMigtLWVsbIz9+/eLbcck5gZhzert7aWxsZH6+nqxt2dISMis+XRnfeX7+Mc/zuOPP87w8DC//vWveemll2b7KySug8Ph4MiRI3zjG98gLy+PLVu2sH379oDnL80Fmzdv5n/9r/+FxWJh165d/Pu//7tkUZhDnE4njY2N/N3f/R1arZaNGzeyY8eOoK6Qr1KpePrppykuLqazs5Mf/ehH1NTUBFqsRYPP58Nut/Nv//ZvvPzyy6xdu5Y777xz1ruez7qiMxgMZGVlsWPHDnp7ezl+/Di1tbXSye4WI5T62r17NydOnMBqtXLfffeJdTwXA1qtluTkZO666y68Xi9Hjx6lrq6OiYmJQIu2oBHG3rFjx3jnnXcwm81s3LiRTZs2BU2k5bWQyWTExcWxYsUK1q1bJ/rqmpqaJLP3LUYImHv11Vfp6OhArVbz6KOPEhsbO+ul4mZd0alUKpKSkrj33nux2+1cuHCBqqoqLBaLZBK4hQjVvvfs2cOFCxfQaDRs27aNgoKCoK0UMtuEhYURHR3N3XffjVqtpqGhgVOnTjE4OIjL5ZIWrluEz+djamqKo0ePUllZSUREBLfddhsVFRVBP/aEVmNLly5l06ZNtLS0cO7cOc6fPy82lZa4NUxPT9PT08Prr7+O1WolMTGRHTt2EBkZOetj5pZUWDUYDNx99910d3dz7NgxvvrVrwKwatUqioqKbsVXLnrq6ur4zW9+w969e1m7di3/8A//QFpaWsBrC841SqWS7du343Q60el0fPOb3+Spp57innvuYcWKFYEWb0EyODjIj3/8Y/bu3YtWq+WnP/0pS5cuDWqT5fspKCggPj6euro6KisrOXHiBCaTicLCwqDtyDLfefHFFzl8+DCHDx/mn//5n1m3bt2sFHC+GrdE0clkMkJCQti4cSNarZaBgQH27NlDf38/YWFhpKamLroF+FYgOHIPHjzIu+++y7Fjx7jzzjtZs2YN+fn5hIaGBvVu+lYgjL2lS5cSHh5Oa2ur2NFbr9eTmJg4ayHLixnhdHz69Gmqq6s5dOgQS5cupbi4mIKCAtRq9bwae3K5HI1Gw0MPPQS81+j05z//OR/72MdYvnw5qamp8+p6ghW/38/U1BQHDx5k3759DA4O8ulPf5qVK1fe0nt8S3tmFBYWolQqqa2tZd++fdhsNvLz89HpdBgMBknZfUiERWZmZkZMkj537hxjY2Ns3ryZsrIy4uPjAyxlYMnIyCAyMpKVK1fy7rvv0tPTw9q1a1EoFISEhBAeHi4tXB8SoaP5xMQEVVVVvPvuu4yMjPCpT32KdevWER8fPy/vrVKpZNWqVfT29mK1Wtm9ezdpaWmoVCqMRiPh4eEBbzM0XxHWrKmpKXp6enjnnXdobW1Fo9Fw7733kpube2vbu/lvIT6fz+/xePzT09P+v//7v/evW7fOr1ar/T/5yU/8p06dupVfvaDx+Xx+l8vlr6qq8n/iE5/wm0wm/7p16/y/+93v/JOTk36fzxdoEQOOz+fz+3w+v8Ph8D/77LP+O++8069Wq/1f+9rX/O+88450jz4Cbrfb39PT4//0pz/tz8rK8mdlZfl/85vf+Ht7e/1erzfQ4n1ohDHjcrn8XV1d/kceecSflZXlz83N9b/88sv+gYGBQIs4b/H5fP6ZmRn/s88+69+xY4c/PDzc/9WvftW/e/duv9frveXz8ZZuT4SWGGFhYXzsYx8jOzsbrVbLrl27uHjxIt3d3dxxxx2zmhi40HG5XExNTfHaa69x7tw5qqur+djHPkZZWRlr164lIiJiXu6mZxuhYalSqWTr1q0kJSUhl8s5e/Ys7e3tTExMsG7dOmJjY4MyxysY8Xq9mM1mDh48yOnTpzlz5gxr1qyhqKiI2267jaioqHk9j4V5o1AoMBqNPPnkk+zatYuGhgZ++tOfik1aN2zYgEKhkObZDWKz2RgeHuaFF17g5MmTWCwWvvKVr7Bt2zays7PnJGDplp/DhQsoLS1FrVYzNjbGCy+8wPT0NAqFgoyMDJKSkoiKilqUPqWbwW63Y7FYaG5u5tChQ3R1daFUKtmwYQPFxcWkpaUFWsSgQphA2dnZREdH09rayltvvUVjYyOHDh0iOjoaj8dDXFwcISEh83qRvtU4nU5sNhv19fVUVlZy5swZQkJCWL58ObfddhtpaWkLZu7K5XJUKhVr1qzBbDYjk8l46aWXOHHiBNPT06SmphIbG0tERMSiyE/9sPh8Pmw2G93d3bS0tPDOO+/gdDqJjY3l7rvvJj8/H4PBMCeyyPz+uYm5Fr7G7/fz+uuvc+DAAV588UVyc3O58847+cxnPkNKSopkA78Ox44do7Kykp/85CdER0dTUVHB1772NbKzswkLC1swC81sc+nYO3ToEMePH+eZZ54hPT2dZcuW8fTTT3+oZpaLidraWk6fPs3TTz+NWq0mIyODZ555htTUVPR6/YIbe5cuixMTE7zxxhv8/Oc/p7u7m8zMTJ5++mlKS0tnpVfaQsXhcPD222/z29/+lnfffZeYmBi+9KUvsWnTJrKysoC5a849Z4pOwO/3Mzg4SFdXFzU1Nbzyyiv4fD4MBgMPPPAAJSUlLFmyZFbLv8xnLBYLfX19vPHGG5w4cYLJyUkMBgMPPvggBQUF5OXloVarJfPbDTI6OsrQ0BDvvvsue/bsYWRkhOjoaLZv305RURGrV6+Wxt5/Y7PZGB8f5+WXX+b8+fN0dXVhNBrZtGmT2Ah2MZxqXC4Xg4ODnD17lvr6enbt2kV0dDRpaWls2bKFTZs2YTAYpE06753ixsbGqKqqoqqqigMHDqBWq4mLi+PjH/84eXl5xMbGolKp5nSOzfkvI5PJSEhIQKfTYTKZqK+vp7m5mebmZiorK3E6nfj9fpKSklCr1URERIjvWyx4vV5cLpfYZqelpYVjx44xMjJCZGQkq1evZsOGDSQmJi74RWa2iYmJQafTodFoGBgY4Pz58zQ2NhIZGYnVahX722k0GjQaDbC4xp7P58Pj8TA6OsrAwACdnZ3i2PN6vVRUVLBu3TqKioqCvurJbKFUKsWUKKPRSHNzM42NjUxNTREaGorBYCA5ORmTyYRer190/jv/f0fh2mw2LBYLDQ0NvPvuu5w5c4bJyUny8vIoLy9nw4YNhIWFBWRTPucnOgHhaz0eDzU1Nezbt49nn30WeG8x+pu/+RtWrlxJQUEBcrl8UQ2cqakpBgYG+PWvf81bb71FX18fiYmJfPGLX6SiooKSkhLxtYvpvswWwtjzer309vby2muv8fzzzzM6OorBYOCJJ56gvLycNWvWLLqxNz09jdls5he/+AVHjx7lzJkzJCcn89BDD3HHHXeI1U5g8Y09/3/nrXo8Hl577TUqKyt58cUXiY6Opri4mIcffpg777wTvV6/qPy9/v8u5XXy5EkOHjzIr3/9a9RqNSkpKfzDP/wDhYWFl6U7BWLcBEzRwf8MHMFEUldXx/nz5zl37hw9PT3ExcWRmprKjh07KCgoEE8wC3GCWa1WxsfH2b9/P6dPnxYjAwsKCsjOzub2228X/SFSwvPs4Pf7cTqdjIyM0NjYSHNzM4cPH6avrw+VSkVGRgZ33303OTk55OXlLdix53A4mJycZN++fdTV1VFbW8vY2BjJycnk5ORw9913k5SUJJ6GF+I9uFGENWtkZITR0VGam5vZs2cPvb29DA8Pk5+fT0FBAatWraKiogKVSrUgTZp+v5+JiQlaW1s5d+4ce/fuZWJigpmZGcrLy1m2bBlF/7+9946O+6wS/j/TZ6RpaqPeR11ykW3J3bHjxMSYFELCu2GBhJrsWcrCu/BjK7zALrt5lxBgDwd2WVqWLIQQkjgkTty75S5ZtiSr9zrS9D7z+yPv94uT2Imd2J6R/HzOmRPFmhnd+c79Pve597mloYGKigpSU1MTXjOd0G9Ayoozm82YTCZMJpN83uRyuZibm8Pj8WCxWJienqakpIS8vDysVqsc1pyPN510s/j9frxeLxMTE4yPjzMyMsLBgwfp7+/H4/FQXFzMihUraGhooLm5+ZYLidxoFAoFBoOBoqIiOZTu9/vZt28fc3NzckhzfHyc6elp8vLysFgsmM3mm37GcL2QdC8UCuHxeJicnGRmZkbWvcHBQSYnJykqKmLx4sWsWLGClStXotVqbykv5UpIa1ZOTg7p6elkZ2czOzuLyWTC5/PR399PIBAgGAwSiUTIysoiLS2N7OxsdDrdvG2wLumN0+nE4/HgcDjo7e3l4sWLtLa2Mjw8jNFopLS0lPXr17NkyRIqKiqSZs1KqEd3JaLRKAMDA+zcuZPdu3fzwgsvoFarSUtL495772Xjxo3U19dTXl5+2dcnw4W9lMtd4kgkQldXF+3t7fzP//wPZ8+eZWhoiPT0dLZu3cratWv58Ic/jE6nW5A7wmQl/v9mY50+fZrf//73bN++nUAgQGpqKvfddx/Nzc2sWrVKvonfzHzRvbGxMc6cOcNvf/tb2tvbaWtrIz09naamJu68807+/M//HJPJJM6ArxKPx8Po6Cg//vGPOXHiBEePHiUlJYW6ujpWrVrFhz/8YYqKisjKyrrs65Ndb6SQ7cGDBzl9+jR79uxh7969KBQK0tLS+PSnP83atWtpbm5OSgckKQ1dPB4nGAzKXl1/fz9tbW10dnZy8uRJIpEIGo2GsrIyFi1aRGlpKUuXLqWwsJDU1NSk23mGw2ECgQDnzp2jp6eHrq4uWlpamJmZwev1kpeXR3V1NeXl5axatYrMzEwsFotcgJtsSrOQkbwdn8+Hw+FgYGCAnp4ezp49y4kTJwgEAgCUl5dTUVFBRUUFzc3N5OTkkJaWlnTfVzQaJRAI0NnZyeDgIGfPnpWnfzscDnJzcykqKqK2tpbVq1eTmZlJWloamZmZKJXKpLuXkpVoNEo4HGZychKHw8Ho6Cg/+clPGBkZYW5uDr1eT1ZWFrm5uaxatYrKykpKSkooKytLGq/nUgKBALOzs1y8eJETJ07Q399Pe3s7ExMTclLOypUrqaiooKqqiry8PEwmE0ajMSknViSlq6BQKNDr9ej1ejIzM7HZbJhMJrKysojH44yMjOByuRgfHwdgZGSEiYkJCgsLsVgscnjJYDCQkpJCamoqGo3mhoUNLk2sCQQCeL1eucDW6XTidrtxOp10dHQwMTHBxMQELpeLlJQUsrKyWLJkCfX19VRUVLB48WJRvJxAFAoFOp0OnU6H1WolKysLm82G2WwmHo8zOjoqn89I2Ymzs7Pk5OSQkZFBWloaRqMRg8GAyWTCYDCg1WpvaIZi/P/Ng/P5fPj9fgKBAG63G5fLhc/nY2Zmhp6eHiYnJxkaGsLhcKBUKuXwZHl5OYsWLWLx4sXo9XpRqvIuUKlUqFQqOQyuVqsJh8Py0YxeryccDjM6OkpLSwsjIyPk5uZSWloqh8KtVispKSno9Xp5zbpR34UUigwGg4RCIbxeLx6PRz6vdTgccnhyYGAAh8OB1+slOzub7Oxs7Ha73CiguLg46UtyktKjuxLSl9PV1UVPTw+7du3iyJEjDAwMMD4+TmpqKhkZGdTX17N48WLy8/MpLy/HbrdjtVrfUoX/Xr6YN182Kb12dHSU7u5uhoeH6e7u5uTJkwwPDzM0NEQ8Hpdl2rJlC0uWLJGTbIRhS24k3RsZGaG7u5tXXnmFs2fPcv78eXkqh8lkYtmyZVRWVspeUlFRERkZGW8JWb3XReFS/YvFYgQCAQYHBxkcHGRsbIy2tjba29sZGhqiu7ubWCyG1WqlpqaGTZs2UVdXR1NTkyhRuY5I38ng4CDHjx/nL//yL6moqOD9738/TU1NcmRgx44dTE1N4Xa7MZlM2O12SkpKaGxspLS0lNzcXOx2O+np6W9pYnA916xIJML4+DhTU1P09PS8wevv7u7G7XYTj8dpaGigsrKSlStXsnnzZnJzc2/YOJ0bxbwzdPB6Aad0mO73+3G73fT19XHx4kXGx8cZHByUEzr8fj9arRa9Xo/JZCI/Px+j0Sh7iKmpqbLXp1arUalU8q5WoVDg9/uJxWJEo1F5t+z3+5mZmcHlcuH1epmZmWFsbAyv1ysfQuv1ennaenZ2Nvn5+TQ0NJCeno7VapV3/dIZXDLvhgRv9NqDwSAej4dAIIDP56O7u5vBwUFGRkbo6elhdHSU2dlZvF6vHEmwWCxkZ2djNpuxWCxkZGSQkpIiJ2Cp1WrUarVcZ6RWq/H5fG/QvWAwSCAQYGpqCo/Hg9frZWpqiqmpKVwuF36/n2g0KvdqLCoqIjs7m5KSEqqrq8nMzCQzMxOj0YhOp5OLvYXuXR/i8Tjt7e3s2LGDH//4x9TX13PnnXdy//33YzAYCIVCcqRHSkBrb29nZGSEyclJent75e9Qq9XKSXo5OTlYLBaMRiNpaWlYLJY3fH9qtRqNRoNGoyESiRAKheRaXCkM73K5cLvdzM3NMTc3h8vlYnh4mGAwSDgcJhqNkpaWhtVqpbS0lNLSUnJycqisrJQLvA0GA0ajUdbV+cS8kla6IaXQkpRmHwwGSU9PJysri6mpKQYHBykuLsbpdDI7O4vb7SYSiRCLxWRj5HK5mJmZkRcVydhIjails5ZIJAL86TBWKqiVDJr0s8FgIDU1Fb1ej9lsxmw2k5GRQVlZGTabjdzcXMrLy+XnCOYXku5JC4pUTB6NRjGbzeTl5TE5OUleXh5jY2M4HA5mZmbweDzyQhIIBGTPf3p6Wl6gVCqVrG9v1j0pLOn3++V/DwQCsu4FAgG0Wi3p6enyQmQ0GsnOzqawsJCsrCyKi4vlkFpqamoiL+OCJRwO4/F42Lt3L2fPniUej7Nu3TqWLFly2QQUm81GQUEBaWlpjI6OMjU1RWFhIXNzc3i9XtxuN7FYDIVCgcvlIhAIyBtqSWcupzexWIxYLCbrjbRRCoVCshEMhUKEw2E5pKrT6TCbzWRmZpKenk5JSQlFRUXyZsloNM77cPa88uiulVAohNvt5uLFi0xMTDAyMsLg4CBOp1M+43O73Xg8HnlBikQi8s/xeByz2Swbw5SUFPkhpQ1LClJcXExWVhZFRUWUlZXdEq2RBFcmGo0yNzfH4OAgExMT9PX1MTo6ytzcHLOzs3LoSlrYJN3z+/2yEZOGl0pnKRkZGdhsNnJycuTNVHZ2Nrm5udhsNsrLyykoKMBisQhP7SYhLZ9Op5O+vj4efvhhIpEI9fX1fP/73ycrK+uajiWks1UpSjA1NcXIyAgOh0OutXU4HPj9fvx+v2y0JM9MigpI/9Xr9RiNRjlvQVq3rFar3FDfZrNRWlp6Q88EE82CNnTSrkbaUUejUdkrk3Y6l+6ApAVl165dPP300/T19bFnz563eHsKhULeTUkPKewp7dKTMfNIcPOQdC8Sich692bdk1onSboHr5+3SSgUCkZGRjh//jxf/vKX+fjHP85f/MVfYLVaZb2TdE6pVMphLGlhFfp345G6guzbt4/vfOc7qNVqbrvtNh577DHy8vKuOaNS0g9p4yPp0JvXLElnLn1IXLr2XOrtSfoi/XypZyhtyheqzsyr0OW1Ihmka9mlBAIBbDYbBoNBzqKar0WegsTxbnTvcmi1Wvx+PwqFQg6ZZmdni+SlJEAqKdi9ezdHjx5lbm6O+++/n9WrV5Obm/uuygYu3TgLrh/iagoESYzBYJBr2qRSATEaJvHE43HC4TAOh4Nf/epX9PX1YbVa+chHPkJZWZk4tkgyxLZQIEhipGkKUlu8sbGxy3Y7EdxcQqEQZ86c4TOf+QxdXV3U19fz05/+FLvdLk9cESQPwqMTCJIYlUqFVqvFaDQSjUaZnZ0Vhi6BSOdhhw4d4tixY/T09LB+/Xqam5vlYw4RVk4+hKETCJIYKYHAYrEQi8VwOBzC0CWISzvQvPzyyxw/fhyv18t9993HkiVLsFqtiRZRcAWEoRMIkhylUkl+fj7weru7SzMzBTeXgYEBnnjiCV555RVycnL4j//4D5qbmzGbzYkWTfA2CEMnECQ5Uof4YDDI7OxsosW5ZTlz5gwnT57k0KFDLFmyhMWLF1NbW0tKSooIVyY54tsRCJIcydABInSZAKRw5bFjx9i7dy99fX2sXr2aLVu2UFhYKMqP5gHCoxMIkhwpdDk2Nsbo6KgIXd5kZmdn+cMf/sCPf/xjfD4f3/72t7n77rvJzc1NtGiCq0QYOoEgyVEoFGRkZKBQKGSPLh6PL9guFsnE4OAgFy5c4OmnnyY3N5eysjI2bNhAWlragm2XtRARoUuBIMlRKBRYrVa5wa/U7Flw45BGH0lDkk+cOIHdbmfjxo3U1taK5tjzDOHRCQRJjkKhID8/n5SUFHlElEajEYvtDSQYDHLy5EmeeOIJWltbefDBB/nUpz5FXV2d8KTnIcKjEwiSHCl0mZqaSjweZ3p6Gr/fn2ixFiyzs7N0dnby5JNP4vF4aGxs5OMf/ziFhYUiXDlPEYZOIEhypNClXq8nHo8zOztLIBBItFgLDql/5dDQEGfPnuXw4cNYLBaamppobm4WBeHzGBG6FAiSHIVCQVZWFmazGaVSyejoKCUlJYkWa8ERi8WYnJzkP/7jP3j55Zex2+089thjbNy4UXhy8xxh6ASCeYBSqSQ1NZW0tDSmpqbw+XyJFmlBEQgEmJ6e5tvf/jYXLlwgJyeHr3zlKyxatGjBz2q7FRChS4EgyZEGaRoMBkwmE06nk2AwmGixFgRS/8qJiQnOnTvHgQMHAKivr2fNmjXYbLZ3NVdOkFwIj04gmCeYTCZsNhsTExN4vd5Ei7NgCAaDPPfcc/zP//wPTqeTRx99lA9+8INYLJZEiya4TghDJxDME4xGI5mZmUxOTgpDdx2QWnt973vf49ChQ3i9Xr71rW/R1NRERkYGIMKVCwVh6ASCeYLBYMBsNjM0NCSyLt8DUrH9zMwM/f39HDhwgGAwiN1uZ+3atWRnZ6PT6RIspeB6IgydQDBPMBqNZGVlMTExgc/nE23A3iNHjhzhmWee4ciRI3ziE5/gIx/5CKWlpWISwQJEGDqBYJ5gMpnIyspiamoKj8dDLBZDqVQKY3eNRCIRfv3rX7Njxw6OHDnCV7/6VTZs2EBNTY24lgsUsXURCOYJer0ei8VCKBTC7/eL8OW7wOVy0dfXx/79+5mamiI/P581a9ZQVlaG0WgUhm6BIgydQDBPMBqN2Gw2YrEYHo9HDGG9BqSJD/39/bz88ss888wzpKSk8Oijj7JmzRry8vISLaLgBiJClwLBPMFsNpOTk4NCocDpdDI+Pk5eXp7wQq6CeDzOsWPHeOGFF/jNb37DQw89xB133MGmTZtQq8UyuNAR37BAME/Q6XSYTCY0Gg2BQACn05lokeYFfr+fubk5du3axcWLF0lNTWXdunXU1tbKk9sFCxth6ASCeYJ0RqfX6/H7/UxPT4u5dG+DdG1mZ2c5d+4cP/nJT7DZbNxxxx3cc889GI3GBEsouFkIQycQzCOUSiW5ublEIhHGxsaEoXsHBgYGePnll/nhD3+I3W5n69atfPSjHyUlJSXRogluIsLQCQTzCGlkTzQaZW5uLtHiJC2RSAS/389rr73GiRMniEQibN68maamJrKyssS55i2GMHQCwTxCqVSSmZlJLBbD4XAIj+5NSNcjEAgwPj7Oz3/+c1wuF+Xl5XzsYx8jOztbFITfgohvXCCYRyiVSvLz84lGo4yPjydanKTE7XazZ88eHnnkEdxuN5s2beKHP/wh2dnZIsPyFkUYOoFgHqFUKklPTycWizE7Oys8ukuIxWJEIhF27tzJvn37mJiYYPPmzaxfv57c3FwxbucWRmxvBIJ5hEKhICMj4w2GTvS8fD1kGYlEcLvdPPfcc1y4cAG1Ws2DDz5IVVUVBoMh0SIKEojw6ASCeYRKpSI/P594PM7U1BTBYJBYLJZosRJOLBbj/PnzfPGLX+TIkSMUFRXxy1/+kkWLFom5cgLh0QkE8wmFQkF6ejo6nY5IJMLc3BwajeaW9Vik0O3Bgwc5duwYZ86cYf369TQ1NVFaWopOpxPJJwJh6ASC+YR0RqfX6+XwpdlsvmUNXSwWw+/3s2fPHo4ePcrU1BR33HEHy5cvJzMzM9HiCZIEYegEgnmEUqmkoKAAk8lENBpleHiYzMxMrFZrokVLCCMjI/z85z/nv//7v7FarTzxxBPccccdpKenJ1o0QRIhDJ1AMI9QKBQYDAZSUlLQaDTMzMzcsuN6zp8/z6lTp3jppZdoaGigoaGBpqYmTCaTCFcK3oDQBoFgHqFQKNDpdBgMBvR6PQ6Hg2AwmGixbiqxWAyfz8fZs2c5evQoXV1dNDY2smnTJsrLy9HpdIkWUZBkCI9OIJiHWCwWbDYbo6OjeL3eRItzU3G73Rw4cIDvf//7TE1N8Vd/9Vf8+Z//OUVFRYkWTZCkCEMnEMxDjEYjVquVqampWyp0OTo6SkdHB//+7/9OamoqdXV13HPPPWRlZYlwpeCKCM0QCOYhKSkpmM1m5ubmbonQZTweJxgM0t3dzcmTJzl+/DiFhYWsWrWKRYsWkZqammgRBUmM8OgEgnmI1WolKyuLlpYWfD5fosW54YRCIXp6evjBD37AsWPHWL16NY8++ijLli1LtGiCeYAwdALBPMRoNJKens7U1BR+vz/R4txQPB4PQ0NDfPvb32ZiYoJFixbxpS99CbvdLvpXCq4KEboUCOYhKSkpmEwmXC4XwWCQaDS64Bo8S/0rh4aG5AxLs9lMY2Mjq1atIi0tTRg5wVUhPDqBYB4iZV26XC7cbjd+v3/BnVPFYjGcTic/+9nP2L59OwaDgUceeYTNmzej1WoTLZ5gHiEMnUAwDzGZTPKk7NnZWYaHhzEYDMzNzeHxeJienmZ2dhar1cqWLVvQarWoVKpEi33VRCIRHA4H//zP/8zJkydJTU3la1/7GsuXL5cNuvDmBFfLLWnootEo4XCYzs5OIpHIG0I+oVCI3t5e3G434XCYU6dOvWVYo0qlwmAwUFhYuOB20YLkIhgM4vf7CQQChMNhIpEIwWCQ8fFxRkZGUCgUdHd3c+DAAXQ6HbOzs7jdbqanp3G5XBQXF3PnnXcm+mNcNdK9OD4+TmdnJ4cPHyYlJYX6+no5XCmGpwquFUV8oQX2rwKv18vk5CSf/OQnmZmZIRqNyr+Lx+N4vV6cTiehUIjS0tK3vD41NZWKigq+9rWvUVdXdzNFF9xiDA0N0d3dTX9/PzMzM8zMzDA0NMTY2BiTk5P09vbKZ3RvxmKxsG7dOl588cUESH7tSEtRLBbjF7/4Bc8++ywtLS185Stf4YMf/CBlZWXCixO8K27JrZFer5eHVzocDhwOh/y7eDwuTyqOx+P09va+5ebKzs5m8+bN6PX6my264Bajt7eX559/nldffVU2aH6/n2AwSDgcJhAIXHYenUKhoLi4+LIbtWTG5/Pxox/9iN27d9Pb28s3v/lN1qxZQ35+fqJFE8xjbklDp1Kp0Gq15OTkMDo6it/vv2LG2pVSt8vLy2/Z0SiCm4dWq8VoNDIwMEAgEECpVF5VhqVSqSQrKwubzXaTJH3vzMzMMDAwwIEDB/D5fJSXl7Nq1SoKCgrEplLwnrhlywtUKhXr1q3Dbrdfc+sgk8nEunXrbtnRKIKbR01NDQ888AB6vV5Ot38nI6dQKFAqlRQVFVFcXHyTJH0r8Xj8so8rPa+1tZVf//rXvPbaa5SXl/O5z32O+vp60tLSEiC9YCFxSxu6jRs3UlFRcdnQz5UoLCykurqaoqIiscsU3HBMJhPFxcVs2bKFqqqqq8qclAxiUVFRwkOX8Xic//zP/+SZZ57B6/Ve1tBFIhFefPFFnnrqKZ599lm5SfPq1atF/0rBdeGWDF3C67venJwcsrOzSUtLY3Z29qrCQYWFhZSVlaHVasXBuOCGI2X4rly5kunpaS5evHhVr4vH42RmZpKVlXWDJbwyoVAIh8PB0aNH0Wg0aDQa1q9fj8lkkuvgPB4PU1NT7Nq1i/HxcfLy8li7di12ux2z2Zww2QULi1t2u6RQKEhPTyc/P5/y8vKrSllWKBTU19fT2Nh4EyQUCF5Ho9Fw9913U1NTc9WvUSgU5ObmkpeXdwMle3tcLhdnz55l7969PP300/zjP/4jPT09smcXj8cZGxvj6NGj/OpXvyISifDggw+yadMmCgsLEya3YOFxy3p0EpWVlWzdupXz58+/4/lHPB6nsbGRlStX3kQJBbc6CoWC/Px8mpqa6OnpYdeuXQSDwSvqqkajIScnh/T09ITWeY6OjvLUU0/hdDrx+/309vby2GOP8b73vY9PfepTOBwOXnjhBZ566ik2b97M3Xffzfvf/37R9URw3bnlDZ3NZqO+vv4dzz40Gg02mw2bzSYOxwU3FYVCgUajoby8nNWrV7Nnz563fa5Op6OgoACDwZCwMy6fz8fk5CRtbW34/X6i0SiBQIDe3l6OHDmC2WwmHA5z8eJFDAYDt99+Ow0NDeLeEtwQbnlDl5ubKy8kCoXisrtkhUKBwWCgpqaG7OxsjEZjAiQV3OpUVlaiVqt5/PHHCQQCb6urFRUVpKSkJEDK15mbm2NkZIRz5869IdnL7XZz+PBhTp48SXp6Orm5uTQ2NvLhD39YnMkJbhi37BmdhF6vJzMzk+bmZgoKCq64AzaZTNx7773k5ubeZAkFgtexWq2UlZVx9913U1lZecUohMFgYPHixQk1HK+++ip79ux5y/0UjUYJhUL4fD4mJiaw2Wxs27YNvV4vkrsEN4xb3tAplUo0Gg2LFi0iOzv7ss+RdskNDQ1i1ylIGEqlEoPBwG233UZRUdFlDUM8HketVies/EUqbWhra+PChQuXLd2Jx+Nyv9ne3l527dpFa2srk5OTN11ewa3BLW/o4PUU7mXLll0xQ02lUpGamioMnSDhaLVaNm/eTGlp6WU9ung8jkajoaSkJCGde2KxGIFAgLa2Ns6fP3/FGlXJ2J07d45f/vKX7Nmzh97eXkKh0IKbqydIPMLQAWq1mk2bNl22zEClUlFXV8fKlSsxm82ic7ogoSiVSvLy8li9ejV33XXXW+o5pU1ZTU1NQs6SHQ4HL730EsPDw+84+VwqMQgEAvyf//N/+Jd/+Rd++ctfEg6Hb5K0glsFYeh4PTSZmppKfn4+drsdtVotLx7xeJzS0lLq6+tRKpXiHEGQUBQKBSqVipqaGjZs2PCWMzCLxUJmZiY6nS4hGZcul4t9+/bhdDqvyTPz+Xy0tbWxfft2zp8/z8zMzA2UUnCrIdwT/pSSnZ+fT01NDT09PW8Ye1JSUiLG8QiSCrvdTjweR6/XE4lEiEQiAKSlpWGz2VCpVDd9UxaNRpmdneXw4cO4XK5req1Go2F8fJxQKERPTw8Wi4WMjIwbJKngVkN4dJdQW1vL+973PuB1T04ygA0NDTQ1NSVYOoHgT0gZmPfddx9lZWWo1WrUajV2u/2aOqhcTwYGBmhvb6etrQ2Px3NVzaelBtRVVVX8xV/8Bb/4xS94//vfn9Bm1IKFh/DoLiEnJ4eamhr0ej3hcFjOxrTZbOh0ukSLJxDIKBQKUlJSuOuuuxgcHKS3t5dYLIbNZkvY7LazZ89y6tSpq3quQqHAarVit9tpaGhg3bp1VFRUyH1kRTNnwfXkljR0l04yjsVi8rDVlJQUcnJySE1NJRAIoNFoqK6uxmQyEYlEiEaj8i5UCg2JMztBIojH42i1Wpqbm3nxxRfRarX4fD7MZjNpaWlvSAS5VE8v9aKkM+f3qsNSUsn58+c5d+4cSqXyiiN5FAoFWq2W1NRUudPLli1b2LRpk2iULrhh3LKGLhaLMT09jcfjwe1243K5iMViuN1u6urqaG9vx+fzUVxczOjoKEeOHEGn05GamkpKSgoZGRmYTCY0Gk2iP47gFkTSYbVaTW1tLSMjI+zevZtYLMbc3ByvvfaavDHT6/VoNBrUajVarRaTyURqaipWqxWLxXJVo3/ejmg0itvt5tChQxw6dEg+L7wUaXNoMBhYtmwZd999Nx/5yEewWCyo1WrhwQluKAvO0MViMSKRCKOjozidTqanp5mYmMDlcjE7O4vD4cDv98uPUChEOBwmHA4Tj8cJh8N0dHQwNzdHJBLhhRdeYN++fRgMBlQqlXwWotfr5YfJZJINX0ZGBjabDYvFIk94TkRigGD+Eo1GiUQiDA8PMzc3x+zsLOPj4zidTpxOJzMzM/j9fgKBAH6/n+7ubkZHRwHYs2cP586dQ6PRyOfMKpVK9t5UKpVs9HQ6HSkpKej1elJTU8nKysJisWC1WsnOziY9PZ20tDSys7Pf1vPzer3s37+f6enptxg5SfdzcnJYvHgxt99+O+Xl5djtdiwWi/DiBDeFeWvopLCIZKT8fj/BYJBQKITH46G7u5upqSlGR0cZGxtjbm6O6elppqamZCN3aQjn0h2lwWCQjZ7b7cbtdsuhGCnUGY1GUSqVaLVa2ahZLBZsNhu5ublkZWWRn59PaWkpBoMBnU6HXq9Hq9Wi1WrfUMIguDWRdDgUChEKhQgGgwQCAYLBIF6vl46ODqamppicnGRkZASHw8Hs7CxTU1P4fD5CoZCsw2q1muzsbHw+H6Ojo7JhujSEeKkOSw+p24rRaCQnJ4e0tDQyMjLIy8uT5zWWl5ej0+nQaDTy5k6j0cieoNfrpaWl5S0zHTUaDWazGavVSmVlJRs3buSBBx4gMzNTDC0W3FQU8XnahkC6abu6uujv7+fw4cOcPXuWwcFBOjs7CYVCqNVqjEYjdrsdm81GQUEBJSUlWCwWLBYL2dnZmEwmTCYTVqtVNngGg4Hdu3fT19fHRz/6UdlLDIVCuN1uvF4v09PTOBwOXC4XU1NT9Pf3Mzk5ydDQEH19fXLH9oyMDPLz86msrGTlypXU1tZSV1dHXl6eCNfc4khG59y5c/T09HD69GmOHz/O4OAg/f39hEIhOVxeWVlJTk4OOTk5lJaWYrVaMZlMcvQA4OTJk6xYsYLCwkJSUlJQqVTE43F5AxiJRAiHwzidTjwej2w0XS4XMzMz9PT0MDExwejoKD09PXKUIz09nfLycsrKymhubmbp0qWUlZWRm5srn81t27aNiYkJgsEgKpWKWCxGQUEBW7Zs4bOf/SwlJSWkpaW94axQILhZzCtDFwqF6Ovro6Ojg4GBAc6dO8fY2Jg8yNFqtWI0GklPT6ekpASr1Up6ejpGoxG9Xo/BYCA1NVWedqzX61Gr1fL/SzefSqViYmICj8dDaWkp8KfEFalmSdqBRyIReQceCATw+Xy43W6cTieTk5MMDg7KZ4AOh0M+iK+qqqKkpISSkhKam5tlGQULG5/Px+DgIGfPnmVoaIiuri6Ghobk+XIZGRkYjUasVivl5eXyOZrRaMRgMMhhRklnJU8LYHZ2lvT0dNnISfocjUbfkHQVDodloxcMBuX/ejweAoEAgUAAp9OJw+FgZmaGgYEBXC4XXq8Xh8OBwWDAZDJRUVFBZmYmc3NzfO973yMQCGAwGKiurmbLli1UVVVRV1dHeXk5KSkpYs6cIGEkdehSMi5zc3N4PB6cTidnzpyhvb2d/v5+Ojo6iEQiaLVaCgsLKS8vJy8vj8rKSmpqauQzhndDTk4O8Xj8mruhSIuJ0+lkdHSU9vZ2RkZG6O/vl89XBgcHcTgcDA8PMzw8jEqlksNGaWlpGAwGkeSyQJA2Ry6XS/7+z58/z8mTJxkaGqK3t5dwOIzRaCQ3N5eKigoKCgrkbjxWq/Wq+6tardbL/vub29a9Uw9MKTQ/MzPD+Pg4586dY2BggOHhYfm8cHBwkOnpaYxGI36/H5/Ph16vJyMjg/r6eu68806qqqrIycm5KtkFghtJUnt0wWAQl8vF73//e/bu3cvp06fp6uqioKCA4uJiNm/ezMqVKykrK8Nut1/2Pd5tiOTSy3Kt73GlSxoKhRgYGKCjo4NXX32VM2fOcOHCBdxuN/X19TQ0NPDQQw/R0NBwxQbTgvmF3+9ncnKSl156iZdeeomOjg56e3spLy+X0+s3bdpEUVERRUVFl32Pmx3mu5L+SufWFy5c4OLFi+zcuZM9e/bQ399PJBKhrq6OhoYGHn74YVasWIHVahUhSkFSkHSGTkos2b9/PydOnKC1tZW+vj7MZjMZGRksX76cmpoa8vLyyMjIwGq1kpKSgsFgSOqbSjpT9Pv98hnf3NwcDoeDlpYW+vv7GR8fZ25ujpKSEsrKyti6dSu1tbVyK6Rk/nyCPxEKhXC5XBw8eJADBw5w8eJFBgcH5YzcRYsWsWTJErKysrBarWRkZMih9WRG0mGPx4PX62VkZIRjx44xMjICQEdHBzMzM/h8Pqqrq6msrOS2225jyZIlGI1Gob+ChJEUoUvpBpqampIzJQ8cOEBHRweDg4NyQondbpfTk+dbHzwpCy41NZXU1FRsNhvRaJRAIIDJZJK9u5aWFnp7e5mZmSE1NVWu5SsoKMBgMIjpCUmKFO6bnp5mdHRU1uHW1lYcDgdms5mamhrsdjtr1qxJ2HSB94Kkw2azGaPRKNfgzczMoFAoMBqNXLx4kTNnztDR0cHs7Czw+rXJy8sjOzub1NRUkYQluOkkhUcXj8cJhUI8/fTTvPLKK7z22mtEIhFWr17N+vXr+cQnPoHFYpHbcC2UneGbL30oFKK9vZ3nnnuOQ4cOsXfvXux2O4sXL+av//qvqaqqkjPsBMlFLBbD4/Hw9NNP87vf/Y5Tp04RiUTYunUrq1ev5qGHHnrDmKeFoMOXWzq8Xi+dnZ387Gc/48SJE7S0tFBXV8eaNWv45Cc/SUNDg0i6Etx0Emro4vE4fX19tLS08Oqrr3L8+HEyMzMpLy/n3nvvJT8/Xy66vhW6J8RiMXw+HzMzM0xPT9Pa2sru3bvp7e3F5/Nx++2309jYyAc+8AE5s06QWCKRCH19fezcuZPDhw9z4sQJSkpKKC8v5wMf+AD5+fmkp6eTlZUlF24vZKLRKH6/n4mJCSYmJujs7OT5559ncnKSQCDAtm3baGpq4rbbbiMlJWXBXw9BcnDT42CSXfV4PExOTrJ//35Onz7N+fPnSU9Pp7a2lqamJlatWoXRaLylmikrlUqMRqOcgWe1WvH7/aSkpHDs2DHa29vx+/1YLBYWLVpEWlravAt/LQQkHZ6dnWVycpJ9+/Zx7Ngxuru7sdlsLFmyhCVLlrBq1apbLoNWpVLJOpyTk4PNZmNycpL29nZaW1s5ffo04XAYlUpFY2MjJpOJlJSURIstWODcVI/u0g4N7e3tvPjii3zve99Dr9dTVVXFN7/5TUpLS8nOzr5ZIiU98XicmZkZXnnlFX7yk5/Q09ODRqPhG9/4Bk1NTVRXVwMLIxQ2H7hUhw8ePMjOnTv57ne/S15eHrW1tXzjG9+gqKjoXZe1LDSk6zUwMMD+/ft5/PHHmZ2dRa/X88QTT1BfX09JSQkgdFhw47iphi4cDuPz+fjud7/L6dOnaW1tZcuWLTQ3N7N+/Xpyc3PRarW31A74nZCSHFwul1wk//Of/5ypqSmKi4v50Ic+xN133y0W1ptEMBjE6XTyL//yL5w5c4bBwUHuuusuNmzYwNKlS8nNzZV7SQre2KpPas139OhRnn/+eSYmJmhsbGTLli3cf//94uxOcMO4KXej1IZobGyMU6dOcfLkSVwuFzU1Naxbt45FixZRXl4OiF3dm1EoFKjVatLT0+U+g8PDw+zatQuXy8WuXbvIy8vDbreLnfENJB6PEwgE6O3tpa2tjVOnThGPx6mtrWX9+vUsWbJE7qIjrv+fkK6FVqslLS2N2tpaeUrIH//4R8bGxti9ezclJSWUlpaSm5v7htcJBNeDG27oLj3POHr0KN/61rfw+/2sW7eOz33uczQ0NNxS53DvhZSUFKqrq/nqV79KSUkJu3fv5he/+AWhUIjNmzfz8Y9/HLVaLXetF1wfpPKX6elpduzYwU9/+lN8Ph8f/vCH+fCHP8yiRYtEYtBVIJUgNDc3s2zZMmw2Gy+//DJPP/00sViMe++9l61btwodFlx3bnjoUuoM8bd/+7d0dXURDAb5x3/8R+rq6iguLkan0wmFvgakr8vtdjM4OMj+/fv50Y9+hMFgYPXq1fzN3/wNGRkZYuG9jrjdbiYmJvjCF77AxMQECoWCf/7nf8Zut5OTkyN0+BqRdNjlcnH+/HmOHTvGk08+SWlpKU1NTfz93/89BoNBZGQKrhs31KMLBAKMjIzwyiuvMDAwQEpKCrfffrvc4krE5K8daUE1m80UFhbS3NwsnxUdP36cQ4cOUVdXR0VFxRueL7h2pHBld3c3+/fvZ2xsjLy8PBobG6mtrSUtLU3o8LtA0kmLxUJ5eTkKhYKWlhYmJydlHa6pqaGgoOANzxcI3i03ZMskhXqcTidtbW088cQTBINBli9fzle/+lXKyspITU29EX/6lsJisdDY2Mijjz7K2rVrOX/+PE8//fQVpzwLrp5LQ+5Hjhzh+9//Pjqdjk2bNvHlL3+ZnJycpG/ZNR+w2WysWLGCL3zhC1RWVtLa2sovf/lL2traiEajiRZPsEC4IR6dlHzyne98h+PHj6PRaPj7v/97li5ditlsFju060x9fT1Go5GCggK++c1vMjMzg9vt5pOf/KTYULxLpPZsX/nKV+jp6SElJYV/+7d/o7y8HJPJJHT4OqJUKlmyZAkajYaGhga+/vWvEwwGGR4e5hOf+ITIYBW8Z26IR+dyudi3bx8XLlwgGo1y3333UV1dTWZm5jWPvRG8PQqFAq1WS3Z2NsuWLaOpqQm1Ws3OnTvp7+9nbm4u0SLOS6ampti3bx8XL17EaDRy7733UlZWJg/oFTp8/VAoFOh0OgoLC1m+fDlNTU24XC727t3L0NAQXq830SIK5jnX3dBFo1Gmpqb43e9+x/DwMFlZWTz22GMUFRWJ84wbiMVioa6ujvvuu4/c3Fz27NlDa2srExMTcihZ8M7E43EikQgDAwM8++yzTE9PY7fb+cxnPkNmZqbIEL6BZGVl0dDQwAMPPIBKpWLv3r20tbXhcDiEDgveE9c9JnD27FkOHjzIr3/9a774xS+yYcMG8vPzRQbVTUChUHDPPfeg1+uZmZnhn/7pn/izP/sz/vIv/xKTyZRo8eYNx44d4+WXX+a3v/0tX//611m1ahV5eXlCh28COp2OBx98EL/fD8D/9//9f3zta1/j3nvvFe3uBO+a62bopMnaLS0tnDhxArvdztKlS6murr5pqe4Oh4O+vj5eeumlt/xOq9ViMpn46Ec/+paJzdKZotSz8M3ce++9VFdXMzExwcDAAFNTU4yMjODxeIjFYmi1WiwWi9yQuqKiAr1ef9PDW1IIqKqqinvuuYd//dd/pauri8OHD3P77beLjjPvgNSFRgpZ2u12GhsbKS0tvSk6LNXqnTt3jgMHDrzl93q9nvT0dD72sY+h1Wrf8LtYLEYoFOL555+ns7PzLa99+OGHKSoqku9Th8NBd3c3XV1duFwuvF6v3KcyLS2NRYsWYbPZbvosRIVCgV6vp7GxkWAwyOOPP865c+fIz8/ntttuEyFjwbviuhm6WCyG1+vl2LFjtLa2snLlShoaGiguLr5ef+IdmZub49y5czz55JP4/X4ikQjhcBidTkdaWhrFxcXcd999bzF08PqIHKkmzev1olQqUalU6HQ6KisrKSoqoq2tjZaWFrq7uzl//jwzMzNEo1H0ej2ZmZmUlpayYcMGMjIy5GGaiaCkpASLxcKPfvQjhoaG2L17N2vXrr0luue/FyKRCD6fj3379uFyuVi5ciX19fXYbLabJoPD4eDo0aM8+eST+Hw+IpEIkUgEvV6PzWajoqKChx566C2GTtqsbd++ne3bt8uGS61Wo9Vq2bJlC4WFhcDrdYF9fX3s2bOH/fv3MzExwczMjNy9JDc3F5/PR2NjI1arNSE1mfX19ZjNZn7wgx/Q0dFBamoq69atk2fiCQTXwnUrGJ+ZmeE3v/kNP/vZz1CpVDz11FPk5eXd1M7ksViMSCRCIBDg8ccf5+DBg+zdu5dHHnmEjRs38sEPfvCyhajSJQgGg0xNTfH5z3+evLw8Kisr+fjHP47b7ebcuXM88MADVFdXs2jRIj772c+Sm5uLSqXC4XDws5/9jFOnTnHs2DE+9rGPsXnzZh544IGb9tnf/HkikQj/+Z//yWuvvcaxY8fYsWMHhYWFYp7d29Df38/27dt54oknWLx4Mf/6r/9KcXHxTfOEJW8rEong9Xr5+te/zuHDh2lra+Mzn/mM3FMzJSXlLYu9pMOBQICLFy/yta99jerqampra3nwwQcxGAwoFAr8fj9f+tKX6Orqwuv18qUvfYnKykoKCwuZnZ3l4MGDvPjii+zZs4dHHnmExx57DLvdftONXTwex+1281//9V8899xzOBwOXnjhBbKzs8W0A8E1c12295JS7tq1i/T0dJYuXYrNZnvLrvNGo1Qq5RDl0qVLqampAaCrq4uxsTH5Zn8z0i5RoVAQi8Xo6+sjMzOT5cuXYzabUalUcrr5unXruOeeeygrKyMrK4vMzEwKCwv5wAc+wPr161EqlbS0tHDu3DkikUhCDtAVCgUqlYpVq1ZRUVGBUqnk6NGjDA0N3XRZ5gOXtvjatWsX5eXlNDQ0kJ2dfVMXeOl70+l0mM1mmpqaKCkpIRqNcv78eRwOxxVr9y71dEKhEL29vZSUlLB48WJMJhNqtZrJyUm2b9/O+fPnMRgMPPLIIyxdupSSkhLS0tLIy8ujqamJD33oQyiVSiKRCLFY7KZ9/jd/Hr1ez7p16ygsLCQajXLo0CGmpqYSIo9gfnNdDF04HGZubo6WlhZyc3NZsmSJfHMliurqaux2O2q1mosXL9Lf308gEHhbw+Pz+ZienmZ8fByr1UpVVZW8+Oj1egoKCtiwYQO33347mZmZGAwGdDodFouFtWvX0tTURGpqKh0dHfT19SXM0MHrC0VdXZ2cEn/8+HGGh4dF9toVCAaDcmeOyspK6urqMJlMCQv1KpVK6uvrKSwsRKlUcv78eUZHRwkGg2/7OrfbzfT0NGNjY+Tm5lJWVga8Hu2YmJjgj3/8IxMTE9hsNh544AEqKirIyMhAo9FgMpmorq5my5YtsvFTq9UJCxVKdXXFxcUYDAaOHDnC9PS00GHBNXNd7uKuri6OHz/O6OgoK1as4I477rgeb/uuUSgUVFdXyzfJ3NwcXV1dHDly5G0XinPnzvHaa6+xYsUKeQGA17s3bNy4kY6ODj7wgQ+Qmpr6hptfmjCQmpoqd18PBoPvuCjdaNRqNbW1tWzdupVXX32VCxcuiI4pV6CtrY3Tp08zOjrK7bffzqpVqxIqj0KhYNGiRdTV1VFYWMjU1BTnz5+npaXlbTuGtLS0cOzYMdasWSMbq3g8ztzcHB0dHfzmN79hyZIlrFmzRq5rvRS1Wk1mZiZHjx7lH/7hH+QWXYlCo9GwYsUK1qxZw/PPP8/g4KDomCK4Zq6Loevu7qajo4PS0lIKCwvJysq6Hm/7nlAqlWRkZLBmzRoMBgOTk5McPHiQQCBwxdf09/dz6tQpVq5cSV5e3htCmpJXp1KpLns+EgwGcbvdTE1NkZmZic1mu2Ko9GYgyV1QUMCqVavwer0MDQ3R3d0tdsOXob29naGhIcrKyigoKCA9PT2h8igUCpRKJfn5+TQ3N6NWqxkYGODo0aNvu9BfuHCBrq4u1q5dS3p6uqx/3d3d9PT0EA6HKS4ufoN+v/nvStm7Go0mocXxkiwVFRU0NjbidDrp7++nv78/IfII5i/XxdANDw8zODhIcXExmZmZSdMiyWq1smzZMgwGAw6HgzNnzhAIBN5y7iA17x0dHaWvr49FixaRmZn5ju9/afLLyMgIY2NjeL1eysrKKCoqQqvVJvw6ZGZmUl1dLU8qHxgYSNi5SzLT29vL1NQUJSUlZGRkJE3rtJycHJYuXYparWZ0dJTW1tbLhsRjsRiBQICBgQHGx8fldnsSQ0NDcug6KyuL1NRUpqamGBgYoLe3l+7ubvr6+hgZGWF6ejqh53NvRpq3GI1GmZiYYHh4ONEiCeYZ1+UQra+vj/7+ft73vvclfCd8KTk5Odxzzz38+7//O729vezatYvp6WksFssbMrei0Sjt7e309/fj9XpZv379VRWn+v1+nE4nfX19/OhHP+LixYtkZWXx13/91yxatOhGfrSrxmg0kpeXR1FRER6Ph9bWVjZt2pRosZKOjo4Opqen5azGZKG8vBydTsd3vvMd+vr68Hq9zM3NoVar39ClJRgM0tbWxsjICLFYjI0bN74hW7Svr4/BwUHgdZ0YGBhg+/bt7Nixg6mpKdxuN1lZWbL39PnPf56MjIykaFxttVrJz8+nqKiI8fFxLly4wIYNGxItlmAe8Z4MnVQ7Nz09jdvtprKyMqm6F+h0OjIyMqipqSEQCDA+Ps6JEydQKBTU19fLz4tEIhw4cAClUklzczNarfZtkxAcDgd79+5l165dDA8P4/V6iUQilJeX8/DDD9PQ0HBVHuHNQAq72u12wuEwPT09InR5CVLt3OTkJKFQiMrKyqRq82UwGMjKyqKuro6LFy/i8/k4cuQIy5Ytkyeaw+ubrr1795Kenk5paelbkkjcbjcejweAZ555BpvNhtls5rOf/axcrnDx4kW6u7t59dVXmZubY+vWrdx5550JDcHDn/q5VlZW4vF4ROhScM28p9BlLBbD7XbjdrsJhUJJN2NOpVKRkpKC3W4nLy+PSCRCe3v7G0IfUs1Za2srKpWKhoaGd8w0i0QiTE9P09fXR09PD8PDwygUCkwmEzabjVgsRjgcvhkf8apQKBRykozU+1LwOtFoFI/HIxuB/Pz8pOogo9FoMBqNVFVVkZGRQTAYpLW19Q1p9rFYDL/fz+nTp0lLS6O6uvotZ2uBQEBOjpLuAZvNxqZNm9i2bRv3338/t912G4WFhbhcLl599VVOnTrF+Ph4UuiLWq0mPz+fQCDA9PR0osURzDPek6GLRqOMj4/j9/vRaDSUlJQkRajjUhQKBZs2baKxsZF4PM5rr71GW1ub/PtIJILH42Hnzp0YDAbe9773vWPtVFZWFp/+9Kf5wx/+wMGDB3nuuefYsGEDg4OD/K//9b944okn2LNnz43+aFeNUqmksLAQhUKRNAtXshAKhRgbGyMUCqHX6ykpKbnp9Z/vhFqt5q677qKqqopQKMRLL71ET0+P/PtIJMLs7Cw7duygqKiIjRs3vuU9wuGwvPnSarUsXbqUb3zjG9TW1sre3Z133smDDz7IRz7yESYnJ9m3bx+//e1vk2LTptFoKCoqkps6CATXwnsOXbpcLsLhMEqlEpPJlFS7YYnFixfT29tLSkoK/f399PT0MDg4SH5+PiMjI7S1tcmF30VFRe8YppF+L5UUFBYW8tBDD2G323G5XOzcuROv10tJSQk1NTUJD4VJ3ia8HsIShu5PRKNRnE4n0WgUtVqd0Nq5K6FSqVi+fDlHjhxBp9PR09NDb28vIyMj5OXl0d3dTWtrK7m5uRQVFZGXl/eW99BqtbIBr66ufkP/zkv1PTc3lxUrVqBWqxkbG+Ps2bNJkZQirS9S1xiB4Fp4T3e0lK0YjUZRKpXo9fqkWyTgdQ8sNzeXnJwcfD4f4+Pj9PX1EY1GmZyc5MKFCxQUFGCz2TAajVd9HqFUKuXQklRkXFVVxdjYmHzekQy7YanLBJDw2r5kQ8pWjMVisg4nOlP2zSgUCnJycsjNzcVms+FyuRgdHWVgYIB4PM7w8LDcCUXKGH3zZ9Dr9fKGKzMz84pz9aTkJaVSidvtTppQt0KhwGAwEI1GhQ4Lrpn3bOiCwSCxWEyuvUk2Q6dQKNBoNBQUFLBp0yYMBgP9/f28/PLLBINBuru72b17N5s2bcJut7+nvyXV7aWkpDA1NcXhw4eT5qaUDN07dYe51YjFYrIOK5XKpNbhiooK1q9fj0qlor29nV27dhGLxTh79izHjx9n69at8lnsm8nIyJAzoo1G4xUzS/V6vWwEA4EATqczKfRFMnTS9yUQXAvv6Y6WwglqtVpOTEnGzhsKhYL8/Hze9773YTAYGBoaYufOnQwMDNDT08PFixdZt27de560IGWHKRQKwuEwbrc7KcI+Ui9SIGlqHJMFlUqFyWSS+5m63e6k7LwhFU5v3rwZtVpNZ2cne/bsYXh4mIsXLzI6OsqmTZvIzs6+7OvLy8spKSkBXp/yIenDmwkEAszNzRGLxTAYDFit1qTQF+mYRDouEAiuhfdk6KRdlkqlIhaL4fP5knKRgNcX+MrKSiwWC+FwmMHBQU6cOCE3e87Nzb3icNKxsTE6OjpobW3F5XJd8W+Ew2F5dI+U8ZkMiwS83scTSLpkoUSjVCpJSUlBqVQSjUbx+XxJ4cFcjszMTOx2OyaTCZ/PR39/Py0tLczNzZGSkvK2Wc/5+fnk5+ej0+mYnp5mdnaWaDT6ls/q9XoZGxsjFothNpvJzc1NCh2Ox+Py6KFkyuwWzA/eUzLKpQko0qG+1WpNysVUKhIvLi7G7XYzOTnJk08+ic1mo7m5GYvFcsVsuz179nDs2DGmp6f50pe+RGNj42WfNzs7y4kTJ/D7/RQUFFBZWZkUyTnxeFw20NdyBnkroFar5QkV4XAYp9NJZmZmUnxvb0bqTVlcXCwnozz++ONkZ2ezbNmyt02kqampYXx8nMzMTDo7O7Hb7YRCobckSo2NjXH8+HEikQiFhYU0NTUlZB7dm5HWF+HRCd4N78mjU6vV8oyzeDxOZ2dnUmdEKZVKNm/eTH19PbFYjM7OTsxmM3fdddc7Lmwej4cdO3bw1FNP8cwzzzA2NobP58Pn8zE2NsZTTz3FT3/6U15++WXZeN59991JcVNGo1G6urqIx+OUlpYKQ3cJOp2OwsJCjEYjwWCQzs7OpD4D0ul03HXXXZSVlREOhzl//jzFxcVs2rTpit+r1HS8urqav/u7vyM1NZWjR4/yt3/7t5w7d46JiQk5W/iZZ57h17/+NWVlZWzatIn77rsvoVNIJEKhEJ2dnaSkpFBUVJRocQTzjPekwQqFgpSUFCwWCwaDgeHhYfx+//WS7bojja7p6upCoVAQj8fJyMigqqrqbXeteXl5VFdX09rayvT0NKdPn8bv96PVauWQSmtrK2NjY+Tl5bF69WpWrlx50+eZXQ5pmOfo6GhShaKSBSl0abVacTqdDA0NJUWm7JVQqVQsXryYkydPyjqcm5tLeXn5275OqVSSlpZGU1MTq1evZnJyku7ubnbu3InFYkGj0dDT08Po6ChpaWmsXbuWpUuXkp2dnXB9kZo6DA8PU1xcfFMnvgsWBu/Z0Gk0GrKzs8nKyqKjo4NNmzYRj8cTfnNcDoVCQXNzM+3t7Wi1WrKysigtLaWuru5t5W1ubqa8vJyMjAwOHTrE0aNH+e1vf8vMzAzhcBi1Wk1xcTGlpaV89KMf5aGHHkrI4NkrEY1G6enpYdmyZdjt9qTLKkwkUop9fn4+0WiUjo4OgsFg0uqwVqtl7dq17Nq1C51OR1ZWFna7naqqqnd8rdlsZunSpfzv//2/OXHiBL/73e/4v//3/+L1egmHwxQWFlJXV8f999/PZz7zmaSpi5Wyu7u6uqivr5eTagSCq+W6xCTsdjsjIyPs27ePBx54QD7gTsaFIi0tjU996lPce++9qFQq0tLS3lFOnU5HTk4OH/zgB7nrrrvkLhPSYb5k8DUaDQaDAbPZnBThHkBugutwOMjKyqKxsVEYustQX18v94v8/Oc/n7Ser0KhICMjg3/4h3/gC1/4AiqVCpvNdk2yVlVVUVxczJ133imXm8TjcTQaDVqtFoPBgMViSRo9GRgYoLW1FafTSXFx8Rv61AoEV8N1WY2Li4spLy/n97//PaOjo0xNTSVleEE6q8jIyJCHql4NSqUSpVKJ1WrFarXeOAFvAJOTk7S3t8t9OJN1AU80drud0dFR/vjHPzI6OkpWVlbSNOa+FEmHc3JyyMnJeVev1+v1cr3cfGBoaIiuri6sVis5OTlJubYIkpvrYuiqqqrwer04nU66u7spKysTyphgJK96cHCQw4cPU1hYSHFx8RULim91lixZwvj4OE6nk46ODtLS0pLS0N1KSDrc2dnJ6dOn5TmPV6oVFAiuxHWJTWRkZFBWVsaKFSs4ceIE27dvvx5vK3iPTE5O0trayv79+9m2bRu1tbWJFikpUSgU2Gw2KioqWL58Oa+++ir79u1LtFi3PLFYjImJCY4fP87p06f50Ic+RGFhYaLFEsxDrouhU6lUmM1mbrvtNrxeLxcuXGBwcJBAIHA93l7wLohGo7S0tNDf349KpWLp0qXCm3sb1Go1WVlZbNiwgbGxMTo7OxkcHEzqDMyFTjAY5NChQ0xMTKDX61m+fHlSDXYWzB+u22mzyWRi27ZtxGIxurq6aG1txePxJG2XiYWMNA9vx44d9Pb2kpWVxfLlyy/b1V7wJ2w2G9u2bWNubk7uhBMKhYQOJwBpqPP27duZmZkhJyeHpqYmYegE74rrZuhSUlJYsWIFGzZsIC8vj29961tcvHhR7IgTwMzMDKdOneKFF14gNTWVz33uc3I/R8GVsVqtNDU1sXHjRpRKJf/0T//ExMREUvZvXeiMjIxw4sQJ/vCHP1BZWcmnPvWppJ2OIkh+rpvWSA2NV61axcqVKxkfH+fIkSOcOnXqev0JwTsQj8cJhUJ0dXXxhz/8AYvFQmVlJcuXL3/HqemC17NrtVotmzZtoq6ujrGxMfbv38+FCxcSLdotg6TDp0+f5pVXXsFms1FfX8/ixYtRKBRChwXviuu+PWpubmbdunVEo1EOHTrEoUOH5DEoghuHFF5zOp20tbXx/PPPU1ZWxqJFi6irqxPe3DVw2223sWzZMiKRCDt37uTUqVMihHkTkOr5ZmdnaWlp4bXXXqOuro5FixZdVUG8QHAlFPHrfPfGYjGmpqb44x//yBNPPIFGo+Fv/uZv2Lhxo4iv30CkNklf+cpXOH36NP39/Tz77LOUlpaSlpYGJGcBf7IhLbZ9fX3s3buXf/zHf6ShoYHPfvazbNmyJSkbli8UpObjX/7yl2lrayMQCPDMM8+Qm5uL0WgEhA4L3h3XvX2HUqnEbDazcuVKmpub6e3t5amnniI9PZ3q6mqR+XeDGBoa4tixY7S0tGA2m/mzP/szCgoKxLSCa0QKj2VlZck67HK5+O///m+5FlHU190YLly4wMmTJzl58iTl5eUsXryY7OzspJz6Lphf3JCTXYPBQE1NDWvWrKG4uJg9e/Zw4sQJuru7RRjzOiJ5Hx6Ph4sXL/Liiy8yPj4utytLS0tLmn6b8w2z2UxNTQ3r16/HbDazd+9eTp06xeDgoNwLU/DekXTY5XLR2trKyy+/zPT0NFVVVWzbti1p+m0K5jfXPXR5KaFQiHPnzvH4449z7Ngxqqur+epXv8ry5cuTYnzNfEdaJJ588kn27dvHq6++yuOPP05zczONjY3i8P49Eo/HCYfD7Nmzh//6r//iwIED3HXXXTzyyCM0NzeLBfg6IDVsfvzxx9m1axfnzp3ju9/9Lk1NTVRWVgodFlwXbmjnYY1GQ3FxMY888giRSITp6WmefPJJPv3pT1NVVUVZWdmN/PMLFmn0zuDgILt27eKll14C4KMf/SirV6+msLBQpGFfJzQaDXV1dXz84x9nbm6OwcFBfvjDHxKLxbDb7aI28V0Sj8eJRqO0t7dz+PBhXnnlFaxWKw899BDNzc3k5OQIHRZcN26ooVMoFKSlpbFx40ZaW1s5cuQIBw8epK6ujnA4jMViwWq1yqNSBO9MLBYjGo3KzZq3b9/O8PAwdXV1bNu2jcrKSuEtXycknczLyyMjI4OjR49y7NgxDh06xJIlS4jFYnJzZOF5XD2xWIxIJML4+DinTp3i5ZdfZnx8nEWLFrF161bKy8uTZvqHYGFwQ0OX8Ke092g0SltbG7/4xS/49a9/TW5uLnfffTef+9znyMjIEOnvV0kgEGBiYoKvf/3rnD59moGBAR5//HFWrFhBQ0ODWHBvAJIORyIR9u3bx3PPPccvfvELli9fzubNm/mrv/or9Hq90OGrxOPxMDExwZe//GU6OzuZnZ3lBz/4AUuWLKG8vFzosOC6c8O3TdIUZJVKJQ8m1ev1XLx4kT/+8Y/4fD6am5u57bbbyMzMFOGKt+HChQucP3+eZ599lv7+fgoLC3n44YdZt24d2dnZ4trdICQdVqvVNDQ0yF1menp6ePHFF/F6vWzcuJGlS5eSmZkpFukrEI/HaW1t5cSJE+zcuZORkREaGxtZtWoVTU1NZGRkCB0W3BBuSnxAuvGtViuNjY3Mzs6i1+vp6enhwIEDhEIhLBYL9fX1mM1mUlNTxa7u/xEOhwkGg0xPT3PixAlOnz7NkSNHsNvtNDQ0sG3bNoqKikR25Q1G0sXs7GzS09OZnp5mx44djIyMsHv3bnQ6HSqVirq6Osxms5wSf6vrsFTf6fP5cDgcHD16lJaWFjk5bdmyZWzdupWCggLhEQtuGDc8dPlmLu3gMTg4yJe+9CW6u7uZm5vjscceY9OmTaxfvx6tVnvLLxIAExMTdHR08G//9m8cPXoUjUbD+9//fr74xS9SVlaGTqcDRCHtzUTS4ampKXp7e/nCF77A8PAw0WiURx99lG3btrFo0SI0Gs0t/73E43FGR0c5duwYP/vZz9i7dy8FBQVs3LiRv/u7vyMzM1POXr3Vr5XgxnHTDZ1EOBzG7/fT1tZGW1sbLS0ttLa2kpmZSWlpKffeey9VVVUUFRXdcjtjn8/HzMwMu3fv5sCBAwwMDDA3N8fatWupqalh5cqVlJWVkZKSIkI9CSQYDOLz+WhtbaWlpUXW5eLiYkpLS/nABz5AXV0dWVlZt5wOezweRkdHOXz4MDt27GBiYgKPx8Mdd9xBTU0NixcvpqKiAq1WK3RYcMNJWGqTRqNBrVbT3NxMeno6er2eoaEhZmdnmZ2dJSMjg7m5Oebm5sjNzcVkMi3ocFAkEiEUCjE1NcXY2BhDQ0NyQ+FAIEBVVRXr16+nrq6OysrKRIsrAHQ6HVqtljVr1mAwGDCbzQwMDDA6OsrMzAxmsxmfz0dxcTHZ2dmYzeYFvbCHw2ECgQAOh4OBgQF6e3vZv38/nZ2daLVa7HY7mzZtwm63U1xcnGhxBbcQCfPoJKQ/H4/HGR8fZ8+ePbz00kv84Q9/wGQyUVBQwKOPPsrKlSuprKxcsCHN2dlZRkdH+dWvfsVrr73GxYsX0ev13H///axbt44PfehD8gSChfj55zOXZhaPj4/z7LPPsm/fPrZv347NZqO8vJyHH36Y2267jby8PDncvNCQQrnPPvsszz33HJOTk+j1ej7xiU+wZs0a7rzzThGmFCSEhBs6CWk8x9zcHNPT05w7d46zZ8/S3t5OX18faWlp2Gw21q9fz9KlSyktLSUvL29e3jBSsezw8DB9fX3s3r2bjo4OhoeH8fv9VFZWYrfb2bx5M3l5eaSlpd2S4a/5hqTDU1NTTE9Pc+HCBY4cOUJPTw+Dg4PYbDby8vJobm5m9erV5Ofnk52dnWix3xWSDnd3d9Pf38/+/ftpbW1lenqaQCAghyZXr15NcXExVquVtLQ0ocOChJA0VZkKhQKdTkd2djZZWVmkp6djMplITU3F7/fjdrsZHBzkyJEjOJ1Oent7KS8vx2q1kpqaSlpaGikpKUk5d00q8nY6nXg8HtxuN1NTU/T399Pf38+ZM2eYnZ0lEolgt9tpamqivr6e1atXo9FoRDbaPEHS4YKCAnJycsjKykKpVGKxWAgGg7jdbvr6+ojFYgSDQfLz8ykqKiI9PZ3U1FQsFgupqalJ2UBBKvJ2Op24XC48Hg9TU1N0dXUxNDREa2srMzMzKBQKKioqWLlyJbW1tTQ3Ny/ocK1gfpA0Ht2ViEajTE9Pc/jwYY4fP85vf/tbJiYmCIVClJaWsnr1ampra9mwYQMVFRWYTKYr3lQ3cvF4u8sYDofx+XwcOXKEc+fOcebMGXbt2oXL5SIWi7Fq1SrWr19PU1MTt99+uzBuC4xwOIzD4WDHjh2cOHGC7du3Mzo6ilqtprCwkNtvv526ujpWrFhBTU3N207SvlE6/E7LgGSojx49yokTJ2hvb2fv3r243W50Oh1NTU1s3bqVxYsXs27dOtRqtTBugqQh6Q2dVIfj8Xjwer3MzMzQ29vL0NAQZ86coa+vj9nZWUKhEFarlfT0dOx2O5WVldhsNgoKCigsLMRkMmE2m2+YjLFYDJ/Px/T0NENDQ0xOTjI4OMiFCxcYHx9nbGwMt9uN0WgkIyODuro67HY7paWllJWVYTabSUlJwWw2i/DOAkPSYafTic/nY3Z2lgsXLjA0NMSFCxfo7OzE4/EQDodJT08nOzuboqIiamtryc7OJicnh6KiIjnCcaNkjMViuFwuOZlkbGyM0dFRzp8/z+joKNPT07jdbtLT00lPT6e2tpba2loKCgooLi7GYrGQkpIij4YSOixIFpLe0F2K1K1/dHSUiYkJWltb6ezsZHx8nOHhYYLBIEqlUj4PMJlMpKenk5OTg9lslm9EjUaDRqNBr9ejVqvlhxQyUqlU8o0aiUTkvxuNRolGo0QiEYLBIKFQSP75UkM8Pj6Oy+Vibm4Oh8NBIBAgEAhgtVrJycmhoKCAJUuWUFpaSmFhIRkZGWJRuEWQdEkyJB0dHbS1tTE5OcnExAR+vx+dTofZbCY9PR2z2YzVaiUvLw+z2YzJZHpbHZb0VqVSoVQqZb29VIcjkYic5RsKhQiHw4RCIdxut6y3o6OjuFwuXC4XMzMzBAIBIpEIVquVwsJCcnNzWbx4MZWVlWRnZ8vnbwJBMjKvDN2V8Pl89Pb2cvbsWfr7+2lra+Ps2bNMTU3hcDgA0Gq1GI1GSkpKsFgsWCwWcnJyMJlM8kNaLAwGg7xo+Hw+eXHw+XzyY2Jigrm5OVwuF5OTkwwNDeHz+YhEIqjVaiwWCwUFBaxYsYLS0lKqqqpYsWIFVqsVk8mU4CsmSDakBgrHjx+nr6+Pzs5OTp48icPhwOl0Aq/PebxUh81ms7yJS01NxWg0ymU7er0ejUZDPB5/gw77/X48Hg8ej4eZmRlmZmZwOp3MzMzQ399PMBgkGo2iVqvJysoiNzeX5uZmKioqKCsrk3VYTFoXzCcWhKGLxWKEQiGCwaBcyxMMBgkEArhcLvr7+3E4HExOTjI9PS0bq7m5Ofx+P36/X96xSokC0WgUeL1WSqlUolKp0Ol0cu2UxWLBaDTK9VM2mw2r1Upubi6FhYWkpqai1+sxGAxoNBq0Wi0Gg0HeaQsElxKNRmXdlTytQCCAz+eTk1imp6dxOBxMTU3h9Xrx+/04nU68Xq+s71LUIRQKEY1GUSgUcjKIWq1Gq9Wi1+vR6/UYjUbMZjMGgwGTyUROTg7p6elkZWVRUlKCwWBAp9NhMBjQarVoNBoMBgNKpVLosGBesSAM3ZWQdrATExPy2cPMzAw+n09eJKSworRISEZTCvdcaui0Wi1arRadTiefl0iLREZGBmazmYyMDGw2G1qtViSUCN4zksEbGxvD6XTidDrlzVogEMDpdOL3+wkGg/IGTTJ0sVgM4A2GTgp36nQ6UlNTMZlMGAwGUlNTsdls8uis7Oxs1Gq10GHBgmBBGzqBQCAQCET8QSAQCAQLGmHoBAKBQLCgEYZOIBAIBAsaYegEAoFAsKARhk4gEAgECxph6AQCgUCwoBGGTiAQCAQLGmHoBAKBQLCgEYZOIBAIBAsaYegEAoFAsKARhk4gEAgECxph6AQCgUCwoBGGTiAQCAQLGmHoBAKBQLCgEYZOIBAIBAsaYegEAoFAsKD5/wEfBKPAuxP4+gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from dowhy.utils.timeseries import create_graph_from_dot_format\n", "\n", @@ -81,9 +92,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Input a csv file with the edges in the graph with the columns: node_1,node_2,time_lag\n", "file_path = \"../datasets/temporal_graph.csv\"\n", @@ -106,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -115,9 +137,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# the outcome node for which effect estimation has to be done, node:6\n", "target_node = 'V6'\n", @@ -127,9 +160,108 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
V6_0V5_-1V7_-3V7_-5V4_-3V4_-7V4_-9
06000000
17500000
28600000
39770400
49880500
\n", + "
" + ], + "text/plain": [ + " V6_0 V5_-1 V7_-3 V7_-5 V4_-3 V4_-7 V4_-9\n", + "0 6 0 0 0 0 0 0\n", + "1 7 5 0 0 0 0 0\n", + "2 8 6 0 0 0 0 0\n", + "3 9 7 7 0 4 0 0\n", + "4 9 8 8 0 5 0 0" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "time_shifted_df = shift_columns_by_lag_using_unrolled_graph(dataframe, unrolled_graph)\n", "time_shifted_df.head()" @@ -146,9 +278,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "['V5_-1', 'V7_-3', 'V7_-5', 'V4_-3', 'V4_-7', 'V4_-9']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "target_node = 'V6_0'\n", "# include all the treatments\n", @@ -159,9 +302,78 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*** Causal Estimate ***\n", + "\n", + "## Identified estimand\n", + "Estimand type: EstimandType.NONPARAMETRIC_ATE\n", + "\n", + "### Estimand : 1\n", + "Estimand name: backdoor\n", + "Estimand expression:\n", + " d \n", + "────────(E[V_6_0|V4_-7])\n", + "d[V₅ ₋₁] \n", + "Estimand assumption 1, Unconfoundedness: If U→{V5_-1} and U→V6_0 then P(V6_0|V5_-1,V4_-7,U) = P(V6_0|V5_-1,V4_-7)\n", + "\n", + "## Realized estimand\n", + "b: V6_0~V5_-1+V4_-7+V5_-1*V7_-3+V5_-1*V7_-5\n", + "Target units: \n", + "\n", + "## Estimate\n", + "Mean value: -0.12612138021763197\n", + "p-value: [0.75401158]\n", + "### Conditional Estimates\n", + "__categorical__V7_-3 __categorical__V7_-5\n", + "(-0.001, 0.6] (-0.001, 5.4] 0.111915\n", + "(0.6, 5.4] (7.8, 9.0] -0.257861\n", + " (9.0, 10.0] -0.314176\n", + "(5.4, 7.8] (-0.001, 5.4] 0.073537\n", + " (7.8, 9.0] -0.285273\n", + "(7.8, 9.0] (-0.001, 5.4] -0.034356\n", + " (5.4, 7.8] -0.216503\n", + " (7.8, 9.0] -0.296238\n", + "(9.0, 10.0] (7.8, 9.0] -0.261853\n", + "dtype: float64\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/scipy/stats/_axis_nan_policy.py:531: UserWarning: kurtosistest only valid for n>=20 ... continuing anyway, n=14\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimator.py:266: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", + " by_effect_mods = data.groupby(effect_modifier_names)\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n", + "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " intercept_parameter = self.model.params[0]\n" + ] + } + ], "source": [ "# perform causal effect estimation on this new dataset\n", "import dowhy\n", @@ -195,7 +407,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -212,9 +424,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from tigramite import plotting as tp\n", "tp.plot_timeseries(dataframe, figsize=(15, 5)); plt.show()" @@ -222,7 +445,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -238,9 +461,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "##\n", + "## Running Tigramite BivCI algorithm\n", + "##\n", + "\n", + "Parameters:\n", + "\n", + "independence test = par_corr\n", + "tau_min = 0\n", + "tau_max = 3\n" + ] + } + ], "source": [ "correlations = pcmci.run_bivci(tau_max=3, val_only=True)['val_matrix']\n", "matrix_lags = np.argmax(np.abs(correlations), axis=2)" @@ -248,9 +488,5454 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "##\n", + "## Optimizing pc_alpha over pc_alpha_list = [0.001, 0.005, 0.01, 0.025, 0.05]\n", + "##\n", + "\n", + "## pc_alpha = 0.001 (1/5):\n", + "\n", + "##\n", + "## Step 1: PC1 algorithm for selecting lagged conditions\n", + "##\n", + "\n", + "Parameters:\n", + "independence test = par_corr\n", + "tau_min = 1\n", + "tau_max = 3\n", + "pc_alpha = [0.001]\n", + "max_conds_dim = None\n", + "max_combinations = 1\n", + "\n", + "\n", + "\n", + "## Variable V1\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V1 (1/21):\n", + " Subset 0: () gives pval = 0.86601 / val = -0.072\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V1 (2/21):\n", + " Subset 0: () gives pval = 0.57469 / val = -0.235\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V1 (3/21):\n", + " Subset 0: () gives pval = 0.13528 / val = -0.576\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V1 (4/21):\n", + " Subset 0: () gives pval = 0.08631 / val = 0.642\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V1 (5/21):\n", + " Subset 0: () gives pval = 1.00000 / val = -0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V1 (6/21):\n", + " Subset 0: () gives pval = 0.08260 / val = -0.647\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V1 (7/21):\n", + " Subset 0: () gives pval = 0.30492 / val = -0.416\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V1 (8/21):\n", + " Subset 0: () gives pval = 0.90322 / val = -0.052\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V1 (9/21):\n", + " Subset 0: () gives pval = 0.59372 / val = 0.224\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V1 (10/21):\n", + " Subset 0: () gives pval = 0.08508 / val = -0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V1 (11/21):\n", + " Subset 0: () gives pval = 0.21081 / val = -0.496\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V1 (12/21):\n", + " Subset 0: () gives pval = 0.26642 / val = 0.447\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V1 (13/21):\n", + " Subset 0: () gives pval = 0.36475 / val = -0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V1 (14/21):\n", + " Subset 0: () gives pval = 0.97472 / val = -0.013\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V1 (15/21):\n", + " Subset 0: () gives pval = 0.28630 / val = 0.431\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V1 (16/21):\n", + " Subset 0: () gives pval = 0.69615 / val = -0.165\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V1 (17/21):\n", + " Subset 0: () gives pval = 0.60470 / val = 0.218\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V1 (18/21):\n", + " Subset 0: () gives pval = 0.64103 / val = 0.196\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V1 (19/21):\n", + " Subset 0: () gives pval = 0.32015 / val = 0.405\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V1 (20/21):\n", + " Subset 0: () gives pval = 0.67332 / val = -0.178\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V1 (21/21):\n", + " Subset 0: () gives pval = 0.52668 / val = 0.265\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V1\n", + "\n", + "## Variable V2\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V2 (1/21):\n", + " Subset 0: () gives pval = 0.12317 / val = -0.591\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V2 (2/21):\n", + " Subset 0: () gives pval = 0.87304 / val = 0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V2 (3/21):\n", + " Subset 0: () gives pval = 0.40658 / val = 0.342\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V2 (4/21):\n", + " Subset 0: () gives pval = 0.87285 / val = -0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V2 (5/21):\n", + " Subset 0: () gives pval = 0.00058 / val = -0.938\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V2 -3) -?> V2 (6/21):\n", + " Subset 0: () gives pval = 0.38647 / val = 0.356\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V2 (7/21):\n", + " Subset 0: () gives pval = 0.18843 / val = -0.518\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V2 (8/21):\n", + " Subset 0: () gives pval = 0.82124 / val = 0.096\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V2 (9/21):\n", + " Subset 0: () gives pval = 0.25844 / val = 0.454\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V2 (10/21):\n", + " Subset 0: () gives pval = 0.08165 / val = -0.649\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V2 (11/21):\n", + " Subset 0: () gives pval = 0.06607 / val = 0.675\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V2 (12/21):\n", + " Subset 0: () gives pval = 0.58825 / val = 0.227\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V2 (13/21):\n", + " Subset 0: () gives pval = 0.38186 / val = -0.359\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V2 (14/21):\n", + " Subset 0: () gives pval = 0.32916 / val = 0.398\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V2 (15/21):\n", + " Subset 0: () gives pval = 0.98847 / val = 0.006\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V2 (16/21):\n", + " Subset 0: () gives pval = 0.32076 / val = 0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V2 (17/21):\n", + " Subset 0: () gives pval = 0.40538 / val = 0.343\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V2 (18/21):\n", + " Subset 0: () gives pval = 0.37909 / val = -0.361\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V2 (19/21):\n", + " Subset 0: () gives pval = 0.96874 / val = -0.017\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V2 (20/21):\n", + " Subset 0: () gives pval = 0.29908 / val = 0.421\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V2 (21/21):\n", + " Subset 0: () gives pval = 0.32576 / val = 0.400\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", + "\n", + "Algorithm converged for variable V2\n", + "\n", + "## Variable V3\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V3 (1/21):\n", + " Subset 0: () gives pval = 0.39391 / val = -0.351\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V3 (2/21):\n", + " Subset 0: () gives pval = 0.75698 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V3 (3/21):\n", + " Subset 0: () gives pval = 0.17237 / val = 0.534\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V3 (4/21):\n", + " Subset 0: () gives pval = 0.25198 / val = 0.460\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V3 (5/21):\n", + " Subset 0: () gives pval = 0.81987 / val = -0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V3 (6/21):\n", + " Subset 0: () gives pval = 0.14919 / val = -0.560\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V3 (7/21):\n", + " Subset 0: () gives pval = 0.92814 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V3 (8/21):\n", + " Subset 0: () gives pval = 0.55198 / val = -0.249\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V3 (9/21):\n", + " Subset 0: () gives pval = 0.87647 / val = -0.066\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V3 (10/21):\n", + " Subset 0: () gives pval = 0.83660 / val = 0.088\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V3 (11/21):\n", + " Subset 0: () gives pval = 0.92891 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V3 (12/21):\n", + " Subset 0: () gives pval = 0.18176 / val = 0.525\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V3 (13/21):\n", + " Subset 0: () gives pval = 0.32210 / val = 0.403\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V3 (14/21):\n", + " Subset 0: () gives pval = 0.67508 / val = -0.177\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V3 (15/21):\n", + " Subset 0: () gives pval = 0.65106 / val = -0.191\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V3 (16/21):\n", + " Subset 0: () gives pval = 0.87265 / val = -0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V3 (17/21):\n", + " Subset 0: () gives pval = 0.73304 / val = 0.144\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V3 (18/21):\n", + " Subset 0: () gives pval = 0.71062 / val = 0.157\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V3 (19/21):\n", + " Subset 0: () gives pval = 0.08132 / val = -0.650\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V3 (20/21):\n", + " Subset 0: () gives pval = 0.65185 / val = -0.190\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V3 (21/21):\n", + " Subset 0: () gives pval = 0.71587 / val = 0.154\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V3\n", + "\n", + "## Variable V4\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V4 (1/21):\n", + " Subset 0: () gives pval = 0.56354 / val = 0.242\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V4 (2/21):\n", + " Subset 0: () gives pval = 0.58558 / val = 0.229\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V4 (3/21):\n", + " Subset 0: () gives pval = 0.96166 / val = -0.020\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V4 (4/21):\n", + " Subset 0: () gives pval = 0.16299 / val = 0.544\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V4 (5/21):\n", + " Subset 0: () gives pval = 0.24064 / val = 0.469\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V4 (6/21):\n", + " Subset 0: () gives pval = 0.06141 / val = -0.684\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V4 (7/21):\n", + " Subset 0: () gives pval = 0.94919 / val = 0.027\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V4 (8/21):\n", + " Subset 0: () gives pval = 0.02698 / val = -0.765\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V4 (9/21):\n", + " Subset 0: () gives pval = 0.35707 / val = -0.377\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V4 (10/21):\n", + " Subset 0: () gives pval = 0.77024 / val = 0.124\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V4 (11/21):\n", + " Subset 0: () gives pval = 0.12671 / val = -0.586\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V4 (12/21):\n", + " Subset 0: () gives pval = 0.87499 / val = -0.067\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V4 (13/21):\n", + " Subset 0: () gives pval = 0.45958 / val = -0.307\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V4 (14/21):\n", + " Subset 0: () gives pval = 0.72738 / val = -0.148\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V4 (15/21):\n", + " Subset 0: () gives pval = 0.29395 / val = -0.425\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V4 (16/21):\n", + " Subset 0: () gives pval = 0.88424 / val = 0.062\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V4 (17/21):\n", + " Subset 0: () gives pval = 0.17711 / val = 0.530\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V4 (18/21):\n", + " Subset 0: () gives pval = 0.81886 / val = 0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V4 (19/21):\n", + " Subset 0: () gives pval = 0.80817 / val = 0.103\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V4 (20/21):\n", + " Subset 0: () gives pval = 0.93921 / val = 0.032\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V4 (21/21):\n", + " Subset 0: () gives pval = 0.21585 / val = 0.492\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V4\n", + "\n", + "## Variable V5\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V5 (1/21):\n", + " Subset 0: () gives pval = 0.37886 / val = -0.362\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V5 (2/21):\n", + " Subset 0: () gives pval = 0.30644 / val = 0.415\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V5 (3/21):\n", + " Subset 0: () gives pval = 0.73999 / val = -0.141\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V5 (4/21):\n", + " Subset 0: () gives pval = 0.95989 / val = -0.021\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V5 (5/21):\n", + " Subset 0: () gives pval = 0.72633 / val = 0.148\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V5 (6/21):\n", + " Subset 0: () gives pval = 0.80597 / val = -0.104\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V5 (7/21):\n", + " Subset 0: () gives pval = 0.42170 / val = 0.332\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V5 (8/21):\n", + " Subset 0: () gives pval = 0.70342 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V5 (9/21):\n", + " Subset 0: () gives pval = 0.16043 / val = -0.547\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V5 (10/21):\n", + " Subset 0: () gives pval = 0.85612 / val = 0.077\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V5 (11/21):\n", + " Subset 0: () gives pval = 0.71488 / val = 0.155\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V5 (12/21):\n", + " Subset 0: () gives pval = 0.74776 / val = -0.136\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V5 (13/21):\n", + " Subset 0: () gives pval = 0.12982 / val = -0.582\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V5 (14/21):\n", + " Subset 0: () gives pval = 0.36498 / val = 0.371\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V5 (15/21):\n", + " Subset 0: () gives pval = 0.40910 / val = -0.341\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V5 (16/21):\n", + " Subset 0: () gives pval = 0.38906 / val = -0.354\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V5 (17/21):\n", + " Subset 0: () gives pval = 0.12547 / val = 0.588\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V5 (18/21):\n", + " Subset 0: () gives pval = 0.73154 / val = -0.145\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V5 (19/21):\n", + " Subset 0: () gives pval = 0.94756 / val = 0.028\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V5 (20/21):\n", + " Subset 0: () gives pval = 0.47394 / val = -0.298\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V5 (21/21):\n", + " Subset 0: () gives pval = 0.19310 / val = 0.513\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V5\n", + "\n", + "## Variable V6\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V6 (1/21):\n", + " Subset 0: () gives pval = 0.38954 / val = 0.354\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V6 (2/21):\n", + " Subset 0: () gives pval = 0.13823 / val = 0.572\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V6 (3/21):\n", + " Subset 0: () gives pval = 0.13173 / val = -0.580\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V6 (4/21):\n", + " Subset 0: () gives pval = 0.45705 / val = -0.309\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V6 (5/21):\n", + " Subset 0: () gives pval = 0.59135 / val = 0.225\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V6 (6/21):\n", + " Subset 0: () gives pval = 0.46932 / val = 0.301\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V6 (7/21):\n", + " Subset 0: () gives pval = 0.19069 / val = -0.516\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V6 (8/21):\n", + " Subset 0: () gives pval = 0.81980 / val = 0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V6 (9/21):\n", + " Subset 0: () gives pval = 0.92754 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V6 (10/21):\n", + " Subset 0: () gives pval = 0.79337 / val = -0.111\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V6 (11/21):\n", + " Subset 0: () gives pval = 0.42452 / val = -0.330\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V6 (12/21):\n", + " Subset 0: () gives pval = 0.11568 / val = -0.600\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V6 (13/21):\n", + " Subset 0: () gives pval = 0.26711 / val = -0.447\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V6 (14/21):\n", + " Subset 0: () gives pval = 0.73415 / val = -0.144\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V6 (15/21):\n", + " Subset 0: () gives pval = 0.89556 / val = 0.056\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V6 (16/21):\n", + " Subset 0: () gives pval = 0.59685 / val = 0.222\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V6 (17/21):\n", + " Subset 0: () gives pval = 0.75751 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V6 (18/21):\n", + " Subset 0: () gives pval = 0.41015 / val = -0.340\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V6 (19/21):\n", + " Subset 0: () gives pval = 0.00000 / val = 0.992\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V7 -2) -?> V6 (20/21):\n", + " Subset 0: () gives pval = 0.48406 / val = 0.291\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V6 (21/21):\n", + " Subset 0: () gives pval = 0.81090 / val = -0.102\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", + "\n", + "Algorithm converged for variable V6\n", + "\n", + "## Variable V7\n", + "\n", + "Iterating through pc_alpha = [0.001]:\n", + "\n", + "# pc_alpha = 0.001 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V7 (1/21):\n", + " Subset 0: () gives pval = 0.10602 / val = 0.613\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V7 (2/21):\n", + " Subset 0: () gives pval = 0.13143 / val = -0.580\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V7 (3/21):\n", + " Subset 0: () gives pval = 0.20399 / val = -0.503\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V7 (4/21):\n", + " Subset 0: () gives pval = 0.31711 / val = 0.407\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V7 (5/21):\n", + " Subset 0: () gives pval = 0.40496 / val = 0.343\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V7 (6/21):\n", + " Subset 0: () gives pval = 0.49089 / val = -0.287\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V7 (7/21):\n", + " Subset 0: () gives pval = 0.92032 / val = 0.043\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V7 (8/21):\n", + " Subset 0: () gives pval = 0.79775 / val = -0.109\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V7 (9/21):\n", + " Subset 0: () gives pval = 0.75377 / val = 0.133\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V7 (10/21):\n", + " Subset 0: () gives pval = 0.75703 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V7 (11/21):\n", + " Subset 0: () gives pval = 0.07150 / val = -0.666\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V7 (12/21):\n", + " Subset 0: () gives pval = 0.87683 / val = 0.066\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V7 (13/21):\n", + " Subset 0: () gives pval = 0.97094 / val = 0.016\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V7 (14/21):\n", + " Subset 0: () gives pval = 0.62396 / val = -0.206\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V7 (15/21):\n", + " Subset 0: () gives pval = 0.16865 / val = 0.538\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V7 (16/21):\n", + " Subset 0: () gives pval = 0.98554 / val = -0.008\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V7 (17/21):\n", + " Subset 0: () gives pval = 0.90824 / val = -0.049\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V7 (18/21):\n", + " Subset 0: () gives pval = 0.13870 / val = 0.572\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V7 (19/21):\n", + " Subset 0: () gives pval = 0.50733 / val = 0.277\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V7 (20/21):\n", + " Subset 0: () gives pval = 0.93834 / val = 0.033\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V7 (21/21):\n", + " Subset 0: () gives pval = 0.92994 / val = -0.037\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V7\n", + "\n", + "## Resulting lagged parent (super)sets:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "##\n", + "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", + "##\n", + "\n", + "Parameters:\n", + "\n", + "independence test = par_corr\n", + "tau_min = 0\n", + "tau_max = 3\n", + "pc_alpha = 0.001\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "reset_lagged_links = False\n", + "max_conds_dim = None\n", + "max_conds_py = None\n", + "max_conds_px = None\n", + "max_conds_px_lagged = None\n", + "fdr_method = none\n", + "\n", + "--------------------------\n", + "Skeleton discovery phase\n", + "--------------------------\n", + "\n", + "Testing contemporaneous condition sets of dimension 0: \n", + "\n", + " Link (V1 0) o?o V2 (1/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V2 -2) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.78838 / val = 0.126\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V3 (2/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.96748 / val = 0.017\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V4 (3/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.39632 / val = 0.349\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V5 (4/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.89723 / val = 0.055\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V6 (5/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.46578 / val = -0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V7 (6/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.32813 / val = 0.399\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V1 (7/44):\n", + " Already removed.\n", + "\n", + " Link (V2 -2) -?> V2 (8/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -4) ]\n", + " Subset 0: () gives pval = 0.00773 / val = -0.887\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V3 (9/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.11874 / val = -0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V4 (10/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.64856 / val = 0.212\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V5 (11/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.33073 / val = 0.434\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V6 (12/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.49710 / val = 0.349\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V7 (13/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.93791 / val = -0.037\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V1 (14/44):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V2 (15/44):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V4 (16/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.30341 / val = 0.417\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V5 (17/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.95447 / val = 0.024\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V6 (18/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.53674 / val = -0.284\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V7 (19/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.25153 / val = -0.460\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V1 (20/44):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V2 (21/44):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V3 (22/44):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V5 (23/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.20930 / val = 0.498\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V6 (24/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.26768 / val = -0.487\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V7 (25/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.92759 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V1 (26/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V2 (27/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V3 (28/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V4 (29/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V6 (30/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.38468 / val = 0.392\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V7 (31/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.32066 / val = -0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V6 0) o?o V1 (32/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V2 (33/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V3 (34/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V4 (35/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V5 (36/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V7 (37/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V7 -1) ]\n", + " Subset 0: () gives pval = 0.09642 / val = -0.675\n", + " Non-significance detected.\n", + "\n", + " Link (V7 0) o?o V1 (38/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V2 (39/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V3 (40/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V4 (41/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V5 (42/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V6 (43/44):\n", + " Already removed.\n", + "\n", + " Link (V7 -1) -?> V6 (44/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.00000 / val = 0.992\n", + " No conditions of dimension 0 left.\n", + "\n", + "Updated contemp. adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged at p = 0.\n", + "\n", + "----------------------------\n", + "Collider orientation phase\n", + "----------------------------\n", + "\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1)\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "\n", + "----------------------------\n", + "Rule orientation phase\n", + "----------------------------\n", + "\n", + "Try rule(s) [1 2 3]\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1)\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## Significant links at alpha = 0.001:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): pval = 0.00000 | val = 0.992\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## pc_alpha = 0.005 (2/5):\n", + "\n", + "##\n", + "## Step 1: PC1 algorithm for selecting lagged conditions\n", + "##\n", + "\n", + "Parameters:\n", + "independence test = par_corr\n", + "tau_min = 1\n", + "tau_max = 3\n", + "pc_alpha = [0.005]\n", + "max_conds_dim = None\n", + "max_combinations = 1\n", + "\n", + "\n", + "\n", + "## Variable V1\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V1 (1/21):\n", + " Subset 0: () gives pval = 0.86601 / val = -0.072\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V1 (2/21):\n", + " Subset 0: () gives pval = 0.57469 / val = -0.235\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V1 (3/21):\n", + " Subset 0: () gives pval = 0.13528 / val = -0.576\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V1 (4/21):\n", + " Subset 0: () gives pval = 0.08631 / val = 0.642\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V1 (5/21):\n", + " Subset 0: () gives pval = 1.00000 / val = -0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V1 (6/21):\n", + " Subset 0: () gives pval = 0.08260 / val = -0.647\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V1 (7/21):\n", + " Subset 0: () gives pval = 0.30492 / val = -0.416\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V1 (8/21):\n", + " Subset 0: () gives pval = 0.90322 / val = -0.052\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V1 (9/21):\n", + " Subset 0: () gives pval = 0.59372 / val = 0.224\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V1 (10/21):\n", + " Subset 0: () gives pval = 0.08508 / val = -0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V1 (11/21):\n", + " Subset 0: () gives pval = 0.21081 / val = -0.496\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V1 (12/21):\n", + " Subset 0: () gives pval = 0.26642 / val = 0.447\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V1 (13/21):\n", + " Subset 0: () gives pval = 0.36475 / val = -0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V1 (14/21):\n", + " Subset 0: () gives pval = 0.97472 / val = -0.013\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V1 (15/21):\n", + " Subset 0: () gives pval = 0.28630 / val = 0.431\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V1 (16/21):\n", + " Subset 0: () gives pval = 0.69615 / val = -0.165\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V1 (17/21):\n", + " Subset 0: () gives pval = 0.60470 / val = 0.218\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V1 (18/21):\n", + " Subset 0: () gives pval = 0.64103 / val = 0.196\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V1 (19/21):\n", + " Subset 0: () gives pval = 0.32015 / val = 0.405\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V1 (20/21):\n", + " Subset 0: () gives pval = 0.67332 / val = -0.178\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V1 (21/21):\n", + " Subset 0: () gives pval = 0.52668 / val = 0.265\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V1\n", + "\n", + "## Variable V2\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V2 (1/21):\n", + " Subset 0: () gives pval = 0.12317 / val = -0.591\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V2 (2/21):\n", + " Subset 0: () gives pval = 0.87304 / val = 0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V2 (3/21):\n", + " Subset 0: () gives pval = 0.40658 / val = 0.342\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V2 (4/21):\n", + " Subset 0: () gives pval = 0.87285 / val = -0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V2 (5/21):\n", + " Subset 0: () gives pval = 0.00058 / val = -0.938\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V2 -3) -?> V2 (6/21):\n", + " Subset 0: () gives pval = 0.38647 / val = 0.356\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V2 (7/21):\n", + " Subset 0: () gives pval = 0.18843 / val = -0.518\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V2 (8/21):\n", + " Subset 0: () gives pval = 0.82124 / val = 0.096\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V2 (9/21):\n", + " Subset 0: () gives pval = 0.25844 / val = 0.454\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V2 (10/21):\n", + " Subset 0: () gives pval = 0.08165 / val = -0.649\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V2 (11/21):\n", + " Subset 0: () gives pval = 0.06607 / val = 0.675\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V2 (12/21):\n", + " Subset 0: () gives pval = 0.58825 / val = 0.227\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V2 (13/21):\n", + " Subset 0: () gives pval = 0.38186 / val = -0.359\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V2 (14/21):\n", + " Subset 0: () gives pval = 0.32916 / val = 0.398\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V2 (15/21):\n", + " Subset 0: () gives pval = 0.98847 / val = 0.006\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V2 (16/21):\n", + " Subset 0: () gives pval = 0.32076 / val = 0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V2 (17/21):\n", + " Subset 0: () gives pval = 0.40538 / val = 0.343\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V2 (18/21):\n", + " Subset 0: () gives pval = 0.37909 / val = -0.361\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V2 (19/21):\n", + " Subset 0: () gives pval = 0.96874 / val = -0.017\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V2 (20/21):\n", + " Subset 0: () gives pval = 0.29908 / val = 0.421\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V2 (21/21):\n", + " Subset 0: () gives pval = 0.32576 / val = 0.400\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", + "\n", + "Algorithm converged for variable V2\n", + "\n", + "## Variable V3\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V3 (1/21):\n", + " Subset 0: () gives pval = 0.39391 / val = -0.351\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V3 (2/21):\n", + " Subset 0: () gives pval = 0.75698 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V3 (3/21):\n", + " Subset 0: () gives pval = 0.17237 / val = 0.534\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V3 (4/21):\n", + " Subset 0: () gives pval = 0.25198 / val = 0.460\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V3 (5/21):\n", + " Subset 0: () gives pval = 0.81987 / val = -0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V3 (6/21):\n", + " Subset 0: () gives pval = 0.14919 / val = -0.560\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V3 (7/21):\n", + " Subset 0: () gives pval = 0.92814 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V3 (8/21):\n", + " Subset 0: () gives pval = 0.55198 / val = -0.249\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V3 (9/21):\n", + " Subset 0: () gives pval = 0.87647 / val = -0.066\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V3 (10/21):\n", + " Subset 0: () gives pval = 0.83660 / val = 0.088\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V3 (11/21):\n", + " Subset 0: () gives pval = 0.92891 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V3 (12/21):\n", + " Subset 0: () gives pval = 0.18176 / val = 0.525\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V3 (13/21):\n", + " Subset 0: () gives pval = 0.32210 / val = 0.403\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V3 (14/21):\n", + " Subset 0: () gives pval = 0.67508 / val = -0.177\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V3 (15/21):\n", + " Subset 0: () gives pval = 0.65106 / val = -0.191\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V3 (16/21):\n", + " Subset 0: () gives pval = 0.87265 / val = -0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V3 (17/21):\n", + " Subset 0: () gives pval = 0.73304 / val = 0.144\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V3 (18/21):\n", + " Subset 0: () gives pval = 0.71062 / val = 0.157\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V3 (19/21):\n", + " Subset 0: () gives pval = 0.08132 / val = -0.650\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V3 (20/21):\n", + " Subset 0: () gives pval = 0.65185 / val = -0.190\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V3 (21/21):\n", + " Subset 0: () gives pval = 0.71587 / val = 0.154\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V3\n", + "\n", + "## Variable V4\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V4 (1/21):\n", + " Subset 0: () gives pval = 0.56354 / val = 0.242\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V4 (2/21):\n", + " Subset 0: () gives pval = 0.58558 / val = 0.229\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V4 (3/21):\n", + " Subset 0: () gives pval = 0.96166 / val = -0.020\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V4 (4/21):\n", + " Subset 0: () gives pval = 0.16299 / val = 0.544\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V4 (5/21):\n", + " Subset 0: () gives pval = 0.24064 / val = 0.469\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V4 (6/21):\n", + " Subset 0: () gives pval = 0.06141 / val = -0.684\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V4 (7/21):\n", + " Subset 0: () gives pval = 0.94919 / val = 0.027\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V4 (8/21):\n", + " Subset 0: () gives pval = 0.02698 / val = -0.765\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V4 (9/21):\n", + " Subset 0: () gives pval = 0.35707 / val = -0.377\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V4 (10/21):\n", + " Subset 0: () gives pval = 0.77024 / val = 0.124\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V4 (11/21):\n", + " Subset 0: () gives pval = 0.12671 / val = -0.586\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V4 (12/21):\n", + " Subset 0: () gives pval = 0.87499 / val = -0.067\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V4 (13/21):\n", + " Subset 0: () gives pval = 0.45958 / val = -0.307\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V4 (14/21):\n", + " Subset 0: () gives pval = 0.72738 / val = -0.148\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V4 (15/21):\n", + " Subset 0: () gives pval = 0.29395 / val = -0.425\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V4 (16/21):\n", + " Subset 0: () gives pval = 0.88424 / val = 0.062\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V4 (17/21):\n", + " Subset 0: () gives pval = 0.17711 / val = 0.530\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V4 (18/21):\n", + " Subset 0: () gives pval = 0.81886 / val = 0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V4 (19/21):\n", + " Subset 0: () gives pval = 0.80817 / val = 0.103\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V4 (20/21):\n", + " Subset 0: () gives pval = 0.93921 / val = 0.032\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V4 (21/21):\n", + " Subset 0: () gives pval = 0.21585 / val = 0.492\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V4\n", + "\n", + "## Variable V5\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V5 (1/21):\n", + " Subset 0: () gives pval = 0.37886 / val = -0.362\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V5 (2/21):\n", + " Subset 0: () gives pval = 0.30644 / val = 0.415\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V5 (3/21):\n", + " Subset 0: () gives pval = 0.73999 / val = -0.141\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V5 (4/21):\n", + " Subset 0: () gives pval = 0.95989 / val = -0.021\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V5 (5/21):\n", + " Subset 0: () gives pval = 0.72633 / val = 0.148\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V5 (6/21):\n", + " Subset 0: () gives pval = 0.80597 / val = -0.104\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V5 (7/21):\n", + " Subset 0: () gives pval = 0.42170 / val = 0.332\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V5 (8/21):\n", + " Subset 0: () gives pval = 0.70342 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V5 (9/21):\n", + " Subset 0: () gives pval = 0.16043 / val = -0.547\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V5 (10/21):\n", + " Subset 0: () gives pval = 0.85612 / val = 0.077\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V5 (11/21):\n", + " Subset 0: () gives pval = 0.71488 / val = 0.155\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V5 (12/21):\n", + " Subset 0: () gives pval = 0.74776 / val = -0.136\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V5 (13/21):\n", + " Subset 0: () gives pval = 0.12982 / val = -0.582\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V5 (14/21):\n", + " Subset 0: () gives pval = 0.36498 / val = 0.371\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V5 (15/21):\n", + " Subset 0: () gives pval = 0.40910 / val = -0.341\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V5 (16/21):\n", + " Subset 0: () gives pval = 0.38906 / val = -0.354\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V5 (17/21):\n", + " Subset 0: () gives pval = 0.12547 / val = 0.588\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V5 (18/21):\n", + " Subset 0: () gives pval = 0.73154 / val = -0.145\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V5 (19/21):\n", + " Subset 0: () gives pval = 0.94756 / val = 0.028\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V5 (20/21):\n", + " Subset 0: () gives pval = 0.47394 / val = -0.298\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V5 (21/21):\n", + " Subset 0: () gives pval = 0.19310 / val = 0.513\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V5\n", + "\n", + "## Variable V6\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V6 (1/21):\n", + " Subset 0: () gives pval = 0.38954 / val = 0.354\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V6 (2/21):\n", + " Subset 0: () gives pval = 0.13823 / val = 0.572\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V6 (3/21):\n", + " Subset 0: () gives pval = 0.13173 / val = -0.580\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V6 (4/21):\n", + " Subset 0: () gives pval = 0.45705 / val = -0.309\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V6 (5/21):\n", + " Subset 0: () gives pval = 0.59135 / val = 0.225\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V6 (6/21):\n", + " Subset 0: () gives pval = 0.46932 / val = 0.301\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V6 (7/21):\n", + " Subset 0: () gives pval = 0.19069 / val = -0.516\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V6 (8/21):\n", + " Subset 0: () gives pval = 0.81980 / val = 0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V6 (9/21):\n", + " Subset 0: () gives pval = 0.92754 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V6 (10/21):\n", + " Subset 0: () gives pval = 0.79337 / val = -0.111\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V6 (11/21):\n", + " Subset 0: () gives pval = 0.42452 / val = -0.330\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V6 (12/21):\n", + " Subset 0: () gives pval = 0.11568 / val = -0.600\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V6 (13/21):\n", + " Subset 0: () gives pval = 0.26711 / val = -0.447\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V6 (14/21):\n", + " Subset 0: () gives pval = 0.73415 / val = -0.144\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V6 (15/21):\n", + " Subset 0: () gives pval = 0.89556 / val = 0.056\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V6 (16/21):\n", + " Subset 0: () gives pval = 0.59685 / val = 0.222\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V6 (17/21):\n", + " Subset 0: () gives pval = 0.75751 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V6 (18/21):\n", + " Subset 0: () gives pval = 0.41015 / val = -0.340\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V6 (19/21):\n", + " Subset 0: () gives pval = 0.00000 / val = 0.992\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V7 -2) -?> V6 (20/21):\n", + " Subset 0: () gives pval = 0.48406 / val = 0.291\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V6 (21/21):\n", + " Subset 0: () gives pval = 0.81090 / val = -0.102\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", + "\n", + "Algorithm converged for variable V6\n", + "\n", + "## Variable V7\n", + "\n", + "Iterating through pc_alpha = [0.005]:\n", + "\n", + "# pc_alpha = 0.005 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V7 (1/21):\n", + " Subset 0: () gives pval = 0.10602 / val = 0.613\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V7 (2/21):\n", + " Subset 0: () gives pval = 0.13143 / val = -0.580\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V7 (3/21):\n", + " Subset 0: () gives pval = 0.20399 / val = -0.503\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V7 (4/21):\n", + " Subset 0: () gives pval = 0.31711 / val = 0.407\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V7 (5/21):\n", + " Subset 0: () gives pval = 0.40496 / val = 0.343\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V7 (6/21):\n", + " Subset 0: () gives pval = 0.49089 / val = -0.287\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V7 (7/21):\n", + " Subset 0: () gives pval = 0.92032 / val = 0.043\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V7 (8/21):\n", + " Subset 0: () gives pval = 0.79775 / val = -0.109\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V7 (9/21):\n", + " Subset 0: () gives pval = 0.75377 / val = 0.133\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V7 (10/21):\n", + " Subset 0: () gives pval = 0.75703 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V7 (11/21):\n", + " Subset 0: () gives pval = 0.07150 / val = -0.666\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V7 (12/21):\n", + " Subset 0: () gives pval = 0.87683 / val = 0.066\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V7 (13/21):\n", + " Subset 0: () gives pval = 0.97094 / val = 0.016\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V7 (14/21):\n", + " Subset 0: () gives pval = 0.62396 / val = -0.206\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V7 (15/21):\n", + " Subset 0: () gives pval = 0.16865 / val = 0.538\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V7 (16/21):\n", + " Subset 0: () gives pval = 0.98554 / val = -0.008\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V7 (17/21):\n", + " Subset 0: () gives pval = 0.90824 / val = -0.049\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V7 (18/21):\n", + " Subset 0: () gives pval = 0.13870 / val = 0.572\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V7 (19/21):\n", + " Subset 0: () gives pval = 0.50733 / val = 0.277\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V7 (20/21):\n", + " Subset 0: () gives pval = 0.93834 / val = 0.033\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V7 (21/21):\n", + " Subset 0: () gives pval = 0.92994 / val = -0.037\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V7\n", + "\n", + "## Resulting lagged parent (super)sets:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "##\n", + "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", + "##\n", + "\n", + "Parameters:\n", + "\n", + "independence test = par_corr\n", + "tau_min = 0\n", + "tau_max = 3\n", + "pc_alpha = 0.005\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "reset_lagged_links = False\n", + "max_conds_dim = None\n", + "max_conds_py = None\n", + "max_conds_px = None\n", + "max_conds_px_lagged = None\n", + "fdr_method = none\n", + "\n", + "--------------------------\n", + "Skeleton discovery phase\n", + "--------------------------\n", + "\n", + "Testing contemporaneous condition sets of dimension 0: \n", + "\n", + " Link (V1 0) o?o V2 (1/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V2 -2) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.78838 / val = 0.126\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V3 (2/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.96748 / val = 0.017\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V4 (3/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.39632 / val = 0.349\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V5 (4/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.89723 / val = 0.055\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V6 (5/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.46578 / val = -0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V7 (6/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.32813 / val = 0.399\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V1 (7/44):\n", + " Already removed.\n", + "\n", + " Link (V2 -2) -?> V2 (8/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -4) ]\n", + " Subset 0: () gives pval = 0.00773 / val = -0.887\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V3 (9/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.11874 / val = -0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V4 (10/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.64856 / val = 0.212\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V5 (11/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.33073 / val = 0.434\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V6 (12/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.49710 / val = 0.349\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V7 (13/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.93791 / val = -0.037\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V1 (14/44):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V2 (15/44):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V4 (16/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.30341 / val = 0.417\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V5 (17/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.95447 / val = 0.024\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V6 (18/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.53674 / val = -0.284\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V7 (19/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.25153 / val = -0.460\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V1 (20/44):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V2 (21/44):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V3 (22/44):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V5 (23/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.20930 / val = 0.498\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V6 (24/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.26768 / val = -0.487\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V7 (25/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.92759 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V1 (26/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V2 (27/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V3 (28/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V4 (29/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V6 (30/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.38468 / val = 0.392\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V7 (31/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.32066 / val = -0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V6 0) o?o V1 (32/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V2 (33/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V3 (34/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V4 (35/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V5 (36/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V7 (37/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V7 -1) ]\n", + " Subset 0: () gives pval = 0.09642 / val = -0.675\n", + " Non-significance detected.\n", + "\n", + " Link (V7 0) o?o V1 (38/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V2 (39/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V3 (40/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V4 (41/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V5 (42/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V6 (43/44):\n", + " Already removed.\n", + "\n", + " Link (V7 -1) -?> V6 (44/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.00000 / val = 0.992\n", + " No conditions of dimension 0 left.\n", + "\n", + "Updated contemp. adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged at p = 0.\n", + "\n", + "----------------------------\n", + "Collider orientation phase\n", + "----------------------------\n", + "\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1)\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "\n", + "----------------------------\n", + "Rule orientation phase\n", + "----------------------------\n", + "\n", + "Try rule(s) [1 2 3]\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1)\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## Significant links at alpha = 0.005:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): pval = 0.00000 | val = 0.992\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## pc_alpha = 0.01 (3/5):\n", + "\n", + "##\n", + "## Step 1: PC1 algorithm for selecting lagged conditions\n", + "##\n", + "\n", + "Parameters:\n", + "independence test = par_corr\n", + "tau_min = 1\n", + "tau_max = 3\n", + "pc_alpha = [0.01]\n", + "max_conds_dim = None\n", + "max_combinations = 1\n", + "\n", + "\n", + "\n", + "## Variable V1\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V1 (1/21):\n", + " Subset 0: () gives pval = 0.86601 / val = -0.072\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V1 (2/21):\n", + " Subset 0: () gives pval = 0.57469 / val = -0.235\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V1 (3/21):\n", + " Subset 0: () gives pval = 0.13528 / val = -0.576\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V1 (4/21):\n", + " Subset 0: () gives pval = 0.08631 / val = 0.642\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V1 (5/21):\n", + " Subset 0: () gives pval = 1.00000 / val = -0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V1 (6/21):\n", + " Subset 0: () gives pval = 0.08260 / val = -0.647\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V1 (7/21):\n", + " Subset 0: () gives pval = 0.30492 / val = -0.416\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V1 (8/21):\n", + " Subset 0: () gives pval = 0.90322 / val = -0.052\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V1 (9/21):\n", + " Subset 0: () gives pval = 0.59372 / val = 0.224\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V1 (10/21):\n", + " Subset 0: () gives pval = 0.08508 / val = -0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V1 (11/21):\n", + " Subset 0: () gives pval = 0.21081 / val = -0.496\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V1 (12/21):\n", + " Subset 0: () gives pval = 0.26642 / val = 0.447\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V1 (13/21):\n", + " Subset 0: () gives pval = 0.36475 / val = -0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V1 (14/21):\n", + " Subset 0: () gives pval = 0.97472 / val = -0.013\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V1 (15/21):\n", + " Subset 0: () gives pval = 0.28630 / val = 0.431\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V1 (16/21):\n", + " Subset 0: () gives pval = 0.69615 / val = -0.165\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V1 (17/21):\n", + " Subset 0: () gives pval = 0.60470 / val = 0.218\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V1 (18/21):\n", + " Subset 0: () gives pval = 0.64103 / val = 0.196\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V1 (19/21):\n", + " Subset 0: () gives pval = 0.32015 / val = 0.405\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V1 (20/21):\n", + " Subset 0: () gives pval = 0.67332 / val = -0.178\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V1 (21/21):\n", + " Subset 0: () gives pval = 0.52668 / val = 0.265\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V1\n", + "\n", + "## Variable V2\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V2 (1/21):\n", + " Subset 0: () gives pval = 0.12317 / val = -0.591\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V2 (2/21):\n", + " Subset 0: () gives pval = 0.87304 / val = 0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V2 (3/21):\n", + " Subset 0: () gives pval = 0.40658 / val = 0.342\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V2 (4/21):\n", + " Subset 0: () gives pval = 0.87285 / val = -0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V2 (5/21):\n", + " Subset 0: () gives pval = 0.00058 / val = -0.938\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V2 -3) -?> V2 (6/21):\n", + " Subset 0: () gives pval = 0.38647 / val = 0.356\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V2 (7/21):\n", + " Subset 0: () gives pval = 0.18843 / val = -0.518\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V2 (8/21):\n", + " Subset 0: () gives pval = 0.82124 / val = 0.096\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V2 (9/21):\n", + " Subset 0: () gives pval = 0.25844 / val = 0.454\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V2 (10/21):\n", + " Subset 0: () gives pval = 0.08165 / val = -0.649\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V2 (11/21):\n", + " Subset 0: () gives pval = 0.06607 / val = 0.675\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V2 (12/21):\n", + " Subset 0: () gives pval = 0.58825 / val = 0.227\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V2 (13/21):\n", + " Subset 0: () gives pval = 0.38186 / val = -0.359\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V2 (14/21):\n", + " Subset 0: () gives pval = 0.32916 / val = 0.398\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V2 (15/21):\n", + " Subset 0: () gives pval = 0.98847 / val = 0.006\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V2 (16/21):\n", + " Subset 0: () gives pval = 0.32076 / val = 0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V2 (17/21):\n", + " Subset 0: () gives pval = 0.40538 / val = 0.343\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V2 (18/21):\n", + " Subset 0: () gives pval = 0.37909 / val = -0.361\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V2 (19/21):\n", + " Subset 0: () gives pval = 0.96874 / val = -0.017\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V2 (20/21):\n", + " Subset 0: () gives pval = 0.29908 / val = 0.421\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V2 (21/21):\n", + " Subset 0: () gives pval = 0.32576 / val = 0.400\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", + "\n", + "Algorithm converged for variable V2\n", + "\n", + "## Variable V3\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V3 (1/21):\n", + " Subset 0: () gives pval = 0.39391 / val = -0.351\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V3 (2/21):\n", + " Subset 0: () gives pval = 0.75698 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V3 (3/21):\n", + " Subset 0: () gives pval = 0.17237 / val = 0.534\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V3 (4/21):\n", + " Subset 0: () gives pval = 0.25198 / val = 0.460\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V3 (5/21):\n", + " Subset 0: () gives pval = 0.81987 / val = -0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V3 (6/21):\n", + " Subset 0: () gives pval = 0.14919 / val = -0.560\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V3 (7/21):\n", + " Subset 0: () gives pval = 0.92814 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V3 (8/21):\n", + " Subset 0: () gives pval = 0.55198 / val = -0.249\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V3 (9/21):\n", + " Subset 0: () gives pval = 0.87647 / val = -0.066\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V3 (10/21):\n", + " Subset 0: () gives pval = 0.83660 / val = 0.088\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V3 (11/21):\n", + " Subset 0: () gives pval = 0.92891 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V3 (12/21):\n", + " Subset 0: () gives pval = 0.18176 / val = 0.525\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V3 (13/21):\n", + " Subset 0: () gives pval = 0.32210 / val = 0.403\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V3 (14/21):\n", + " Subset 0: () gives pval = 0.67508 / val = -0.177\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V3 (15/21):\n", + " Subset 0: () gives pval = 0.65106 / val = -0.191\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V3 (16/21):\n", + " Subset 0: () gives pval = 0.87265 / val = -0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V3 (17/21):\n", + " Subset 0: () gives pval = 0.73304 / val = 0.144\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V3 (18/21):\n", + " Subset 0: () gives pval = 0.71062 / val = 0.157\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V3 (19/21):\n", + " Subset 0: () gives pval = 0.08132 / val = -0.650\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V3 (20/21):\n", + " Subset 0: () gives pval = 0.65185 / val = -0.190\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V3 (21/21):\n", + " Subset 0: () gives pval = 0.71587 / val = 0.154\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V3\n", + "\n", + "## Variable V4\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V4 (1/21):\n", + " Subset 0: () gives pval = 0.56354 / val = 0.242\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V4 (2/21):\n", + " Subset 0: () gives pval = 0.58558 / val = 0.229\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V4 (3/21):\n", + " Subset 0: () gives pval = 0.96166 / val = -0.020\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V4 (4/21):\n", + " Subset 0: () gives pval = 0.16299 / val = 0.544\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V4 (5/21):\n", + " Subset 0: () gives pval = 0.24064 / val = 0.469\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V4 (6/21):\n", + " Subset 0: () gives pval = 0.06141 / val = -0.684\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V4 (7/21):\n", + " Subset 0: () gives pval = 0.94919 / val = 0.027\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V4 (8/21):\n", + " Subset 0: () gives pval = 0.02698 / val = -0.765\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V4 (9/21):\n", + " Subset 0: () gives pval = 0.35707 / val = -0.377\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V4 (10/21):\n", + " Subset 0: () gives pval = 0.77024 / val = 0.124\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V4 (11/21):\n", + " Subset 0: () gives pval = 0.12671 / val = -0.586\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V4 (12/21):\n", + " Subset 0: () gives pval = 0.87499 / val = -0.067\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V4 (13/21):\n", + " Subset 0: () gives pval = 0.45958 / val = -0.307\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V4 (14/21):\n", + " Subset 0: () gives pval = 0.72738 / val = -0.148\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V4 (15/21):\n", + " Subset 0: () gives pval = 0.29395 / val = -0.425\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V4 (16/21):\n", + " Subset 0: () gives pval = 0.88424 / val = 0.062\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V4 (17/21):\n", + " Subset 0: () gives pval = 0.17711 / val = 0.530\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V4 (18/21):\n", + " Subset 0: () gives pval = 0.81886 / val = 0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V4 (19/21):\n", + " Subset 0: () gives pval = 0.80817 / val = 0.103\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V4 (20/21):\n", + " Subset 0: () gives pval = 0.93921 / val = 0.032\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V4 (21/21):\n", + " Subset 0: () gives pval = 0.21585 / val = 0.492\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V4\n", + "\n", + "## Variable V5\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V5 (1/21):\n", + " Subset 0: () gives pval = 0.37886 / val = -0.362\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V5 (2/21):\n", + " Subset 0: () gives pval = 0.30644 / val = 0.415\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V5 (3/21):\n", + " Subset 0: () gives pval = 0.73999 / val = -0.141\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V5 (4/21):\n", + " Subset 0: () gives pval = 0.95989 / val = -0.021\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V5 (5/21):\n", + " Subset 0: () gives pval = 0.72633 / val = 0.148\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V5 (6/21):\n", + " Subset 0: () gives pval = 0.80597 / val = -0.104\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V5 (7/21):\n", + " Subset 0: () gives pval = 0.42170 / val = 0.332\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V5 (8/21):\n", + " Subset 0: () gives pval = 0.70342 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V5 (9/21):\n", + " Subset 0: () gives pval = 0.16043 / val = -0.547\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V5 (10/21):\n", + " Subset 0: () gives pval = 0.85612 / val = 0.077\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V5 (11/21):\n", + " Subset 0: () gives pval = 0.71488 / val = 0.155\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V5 (12/21):\n", + " Subset 0: () gives pval = 0.74776 / val = -0.136\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V5 (13/21):\n", + " Subset 0: () gives pval = 0.12982 / val = -0.582\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V5 (14/21):\n", + " Subset 0: () gives pval = 0.36498 / val = 0.371\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V5 (15/21):\n", + " Subset 0: () gives pval = 0.40910 / val = -0.341\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V5 (16/21):\n", + " Subset 0: () gives pval = 0.38906 / val = -0.354\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V5 (17/21):\n", + " Subset 0: () gives pval = 0.12547 / val = 0.588\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V5 (18/21):\n", + " Subset 0: () gives pval = 0.73154 / val = -0.145\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V5 (19/21):\n", + " Subset 0: () gives pval = 0.94756 / val = 0.028\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V5 (20/21):\n", + " Subset 0: () gives pval = 0.47394 / val = -0.298\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V5 (21/21):\n", + " Subset 0: () gives pval = 0.19310 / val = 0.513\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V5\n", + "\n", + "## Variable V6\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V6 (1/21):\n", + " Subset 0: () gives pval = 0.38954 / val = 0.354\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V6 (2/21):\n", + " Subset 0: () gives pval = 0.13823 / val = 0.572\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V6 (3/21):\n", + " Subset 0: () gives pval = 0.13173 / val = -0.580\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V6 (4/21):\n", + " Subset 0: () gives pval = 0.45705 / val = -0.309\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V6 (5/21):\n", + " Subset 0: () gives pval = 0.59135 / val = 0.225\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V6 (6/21):\n", + " Subset 0: () gives pval = 0.46932 / val = 0.301\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V6 (7/21):\n", + " Subset 0: () gives pval = 0.19069 / val = -0.516\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V6 (8/21):\n", + " Subset 0: () gives pval = 0.81980 / val = 0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V6 (9/21):\n", + " Subset 0: () gives pval = 0.92754 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V6 (10/21):\n", + " Subset 0: () gives pval = 0.79337 / val = -0.111\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V6 (11/21):\n", + " Subset 0: () gives pval = 0.42452 / val = -0.330\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V6 (12/21):\n", + " Subset 0: () gives pval = 0.11568 / val = -0.600\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V6 (13/21):\n", + " Subset 0: () gives pval = 0.26711 / val = -0.447\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V6 (14/21):\n", + " Subset 0: () gives pval = 0.73415 / val = -0.144\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V6 (15/21):\n", + " Subset 0: () gives pval = 0.89556 / val = 0.056\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V6 (16/21):\n", + " Subset 0: () gives pval = 0.59685 / val = 0.222\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V6 (17/21):\n", + " Subset 0: () gives pval = 0.75751 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V6 (18/21):\n", + " Subset 0: () gives pval = 0.41015 / val = -0.340\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V6 (19/21):\n", + " Subset 0: () gives pval = 0.00000 / val = 0.992\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V7 -2) -?> V6 (20/21):\n", + " Subset 0: () gives pval = 0.48406 / val = 0.291\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V6 (21/21):\n", + " Subset 0: () gives pval = 0.81090 / val = -0.102\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", + "\n", + "Algorithm converged for variable V6\n", + "\n", + "## Variable V7\n", + "\n", + "Iterating through pc_alpha = [0.01]:\n", + "\n", + "# pc_alpha = 0.01 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V7 (1/21):\n", + " Subset 0: () gives pval = 0.10602 / val = 0.613\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V7 (2/21):\n", + " Subset 0: () gives pval = 0.13143 / val = -0.580\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V7 (3/21):\n", + " Subset 0: () gives pval = 0.20399 / val = -0.503\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V7 (4/21):\n", + " Subset 0: () gives pval = 0.31711 / val = 0.407\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V7 (5/21):\n", + " Subset 0: () gives pval = 0.40496 / val = 0.343\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V7 (6/21):\n", + " Subset 0: () gives pval = 0.49089 / val = -0.287\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V7 (7/21):\n", + " Subset 0: () gives pval = 0.92032 / val = 0.043\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V7 (8/21):\n", + " Subset 0: () gives pval = 0.79775 / val = -0.109\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V7 (9/21):\n", + " Subset 0: () gives pval = 0.75377 / val = 0.133\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V7 (10/21):\n", + " Subset 0: () gives pval = 0.75703 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V7 (11/21):\n", + " Subset 0: () gives pval = 0.07150 / val = -0.666\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V7 (12/21):\n", + " Subset 0: () gives pval = 0.87683 / val = 0.066\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V7 (13/21):\n", + " Subset 0: () gives pval = 0.97094 / val = 0.016\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V7 (14/21):\n", + " Subset 0: () gives pval = 0.62396 / val = -0.206\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V7 (15/21):\n", + " Subset 0: () gives pval = 0.16865 / val = 0.538\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V7 (16/21):\n", + " Subset 0: () gives pval = 0.98554 / val = -0.008\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V7 (17/21):\n", + " Subset 0: () gives pval = 0.90824 / val = -0.049\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V7 (18/21):\n", + " Subset 0: () gives pval = 0.13870 / val = 0.572\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V7 (19/21):\n", + " Subset 0: () gives pval = 0.50733 / val = 0.277\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V7 (20/21):\n", + " Subset 0: () gives pval = 0.93834 / val = 0.033\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V7 (21/21):\n", + " Subset 0: () gives pval = 0.92994 / val = -0.037\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V7\n", + "\n", + "## Resulting lagged parent (super)sets:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "##\n", + "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", + "##\n", + "\n", + "Parameters:\n", + "\n", + "independence test = par_corr\n", + "tau_min = 0\n", + "tau_max = 3\n", + "pc_alpha = 0.01\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "reset_lagged_links = False\n", + "max_conds_dim = None\n", + "max_conds_py = None\n", + "max_conds_px = None\n", + "max_conds_px_lagged = None\n", + "fdr_method = none\n", + "\n", + "--------------------------\n", + "Skeleton discovery phase\n", + "--------------------------\n", + "\n", + "Testing contemporaneous condition sets of dimension 0: \n", + "\n", + " Link (V1 0) o?o V2 (1/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V2 -2) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.78838 / val = 0.126\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V3 (2/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.96748 / val = 0.017\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V4 (3/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.39632 / val = 0.349\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V5 (4/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.89723 / val = 0.055\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V6 (5/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.46578 / val = -0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V7 (6/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.32813 / val = 0.399\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V1 (7/44):\n", + " Already removed.\n", + "\n", + " Link (V2 -2) -?> V2 (8/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -4) ]\n", + " Subset 0: () gives pval = 0.00773 / val = -0.887\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V2 0) o?o V3 (9/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.11874 / val = -0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V4 (10/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.64856 / val = 0.212\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V5 (11/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.33073 / val = 0.434\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V6 (12/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.49710 / val = 0.349\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V7 (13/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.93791 / val = -0.037\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V1 (14/44):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V2 (15/44):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V4 (16/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.30341 / val = 0.417\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V5 (17/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.95447 / val = 0.024\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V6 (18/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.53674 / val = -0.284\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V7 (19/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.25153 / val = -0.460\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V1 (20/44):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V2 (21/44):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V3 (22/44):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V5 (23/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.20930 / val = 0.498\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V6 (24/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.26768 / val = -0.487\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V7 (25/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.92759 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V1 (26/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V2 (27/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V3 (28/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V4 (29/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V6 (30/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.38468 / val = 0.392\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V7 (31/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.32066 / val = -0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V6 0) o?o V1 (32/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V2 (33/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V3 (34/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V4 (35/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V5 (36/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V7 (37/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V7 -1) ]\n", + " Subset 0: () gives pval = 0.09642 / val = -0.675\n", + " Non-significance detected.\n", + "\n", + " Link (V7 0) o?o V1 (38/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V2 (39/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V3 (40/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V4 (41/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V5 (42/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V6 (43/44):\n", + " Already removed.\n", + "\n", + " Link (V7 -1) -?> V6 (44/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.00000 / val = 0.992\n", + " No conditions of dimension 0 left.\n", + "\n", + "Updated contemp. adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged at p = 0.\n", + "\n", + "----------------------------\n", + "Collider orientation phase\n", + "----------------------------\n", + "\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2)\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1)\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "\n", + "----------------------------\n", + "Rule orientation phase\n", + "----------------------------\n", + "\n", + "Try rule(s) [1 2 3]\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2)\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1)\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## Significant links at alpha = 0.01:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): pval = 0.00773 | val = -0.887\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): pval = 0.00000 | val = 0.992\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## pc_alpha = 0.025 (4/5):\n", + "\n", + "##\n", + "## Step 1: PC1 algorithm for selecting lagged conditions\n", + "##\n", + "\n", + "Parameters:\n", + "independence test = par_corr\n", + "tau_min = 1\n", + "tau_max = 3\n", + "pc_alpha = [0.025]\n", + "max_conds_dim = None\n", + "max_combinations = 1\n", + "\n", + "\n", + "\n", + "## Variable V1\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V1 (1/21):\n", + " Subset 0: () gives pval = 0.86601 / val = -0.072\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V1 (2/21):\n", + " Subset 0: () gives pval = 0.57469 / val = -0.235\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V1 (3/21):\n", + " Subset 0: () gives pval = 0.13528 / val = -0.576\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V1 (4/21):\n", + " Subset 0: () gives pval = 0.08631 / val = 0.642\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V1 (5/21):\n", + " Subset 0: () gives pval = 1.00000 / val = -0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V1 (6/21):\n", + " Subset 0: () gives pval = 0.08260 / val = -0.647\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V1 (7/21):\n", + " Subset 0: () gives pval = 0.30492 / val = -0.416\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V1 (8/21):\n", + " Subset 0: () gives pval = 0.90322 / val = -0.052\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V1 (9/21):\n", + " Subset 0: () gives pval = 0.59372 / val = 0.224\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V1 (10/21):\n", + " Subset 0: () gives pval = 0.08508 / val = -0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V1 (11/21):\n", + " Subset 0: () gives pval = 0.21081 / val = -0.496\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V1 (12/21):\n", + " Subset 0: () gives pval = 0.26642 / val = 0.447\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V1 (13/21):\n", + " Subset 0: () gives pval = 0.36475 / val = -0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V1 (14/21):\n", + " Subset 0: () gives pval = 0.97472 / val = -0.013\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V1 (15/21):\n", + " Subset 0: () gives pval = 0.28630 / val = 0.431\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V1 (16/21):\n", + " Subset 0: () gives pval = 0.69615 / val = -0.165\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V1 (17/21):\n", + " Subset 0: () gives pval = 0.60470 / val = 0.218\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V1 (18/21):\n", + " Subset 0: () gives pval = 0.64103 / val = 0.196\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V1 (19/21):\n", + " Subset 0: () gives pval = 0.32015 / val = 0.405\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V1 (20/21):\n", + " Subset 0: () gives pval = 0.67332 / val = -0.178\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V1 (21/21):\n", + " Subset 0: () gives pval = 0.52668 / val = 0.265\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V1\n", + "\n", + "## Variable V2\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V2 (1/21):\n", + " Subset 0: () gives pval = 0.12317 / val = -0.591\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V2 (2/21):\n", + " Subset 0: () gives pval = 0.87304 / val = 0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V2 (3/21):\n", + " Subset 0: () gives pval = 0.40658 / val = 0.342\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V2 (4/21):\n", + " Subset 0: () gives pval = 0.87285 / val = -0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V2 (5/21):\n", + " Subset 0: () gives pval = 0.00058 / val = -0.938\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V2 -3) -?> V2 (6/21):\n", + " Subset 0: () gives pval = 0.38647 / val = 0.356\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V2 (7/21):\n", + " Subset 0: () gives pval = 0.18843 / val = -0.518\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V2 (8/21):\n", + " Subset 0: () gives pval = 0.82124 / val = 0.096\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V2 (9/21):\n", + " Subset 0: () gives pval = 0.25844 / val = 0.454\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V2 (10/21):\n", + " Subset 0: () gives pval = 0.08165 / val = -0.649\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V2 (11/21):\n", + " Subset 0: () gives pval = 0.06607 / val = 0.675\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V2 (12/21):\n", + " Subset 0: () gives pval = 0.58825 / val = 0.227\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V2 (13/21):\n", + " Subset 0: () gives pval = 0.38186 / val = -0.359\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V2 (14/21):\n", + " Subset 0: () gives pval = 0.32916 / val = 0.398\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V2 (15/21):\n", + " Subset 0: () gives pval = 0.98847 / val = 0.006\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V2 (16/21):\n", + " Subset 0: () gives pval = 0.32076 / val = 0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V2 (17/21):\n", + " Subset 0: () gives pval = 0.40538 / val = 0.343\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V2 (18/21):\n", + " Subset 0: () gives pval = 0.37909 / val = -0.361\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V2 (19/21):\n", + " Subset 0: () gives pval = 0.96874 / val = -0.017\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V2 (20/21):\n", + " Subset 0: () gives pval = 0.29908 / val = 0.421\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V2 (21/21):\n", + " Subset 0: () gives pval = 0.32576 / val = 0.400\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", + "\n", + "Algorithm converged for variable V2\n", + "\n", + "## Variable V3\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V3 (1/21):\n", + " Subset 0: () gives pval = 0.39391 / val = -0.351\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V3 (2/21):\n", + " Subset 0: () gives pval = 0.75698 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V3 (3/21):\n", + " Subset 0: () gives pval = 0.17237 / val = 0.534\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V3 (4/21):\n", + " Subset 0: () gives pval = 0.25198 / val = 0.460\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V3 (5/21):\n", + " Subset 0: () gives pval = 0.81987 / val = -0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V3 (6/21):\n", + " Subset 0: () gives pval = 0.14919 / val = -0.560\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V3 (7/21):\n", + " Subset 0: () gives pval = 0.92814 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V3 (8/21):\n", + " Subset 0: () gives pval = 0.55198 / val = -0.249\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V3 (9/21):\n", + " Subset 0: () gives pval = 0.87647 / val = -0.066\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V3 (10/21):\n", + " Subset 0: () gives pval = 0.83660 / val = 0.088\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V3 (11/21):\n", + " Subset 0: () gives pval = 0.92891 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V3 (12/21):\n", + " Subset 0: () gives pval = 0.18176 / val = 0.525\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V3 (13/21):\n", + " Subset 0: () gives pval = 0.32210 / val = 0.403\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V3 (14/21):\n", + " Subset 0: () gives pval = 0.67508 / val = -0.177\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V3 (15/21):\n", + " Subset 0: () gives pval = 0.65106 / val = -0.191\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V3 (16/21):\n", + " Subset 0: () gives pval = 0.87265 / val = -0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V3 (17/21):\n", + " Subset 0: () gives pval = 0.73304 / val = 0.144\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V3 (18/21):\n", + " Subset 0: () gives pval = 0.71062 / val = 0.157\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V3 (19/21):\n", + " Subset 0: () gives pval = 0.08132 / val = -0.650\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V3 (20/21):\n", + " Subset 0: () gives pval = 0.65185 / val = -0.190\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V3 (21/21):\n", + " Subset 0: () gives pval = 0.71587 / val = 0.154\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V3\n", + "\n", + "## Variable V4\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V4 (1/21):\n", + " Subset 0: () gives pval = 0.56354 / val = 0.242\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V4 (2/21):\n", + " Subset 0: () gives pval = 0.58558 / val = 0.229\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V4 (3/21):\n", + " Subset 0: () gives pval = 0.96166 / val = -0.020\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V4 (4/21):\n", + " Subset 0: () gives pval = 0.16299 / val = 0.544\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V4 (5/21):\n", + " Subset 0: () gives pval = 0.24064 / val = 0.469\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V4 (6/21):\n", + " Subset 0: () gives pval = 0.06141 / val = -0.684\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V4 (7/21):\n", + " Subset 0: () gives pval = 0.94919 / val = 0.027\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V4 (8/21):\n", + " Subset 0: () gives pval = 0.02698 / val = -0.765\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V4 (9/21):\n", + " Subset 0: () gives pval = 0.35707 / val = -0.377\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V4 (10/21):\n", + " Subset 0: () gives pval = 0.77024 / val = 0.124\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V4 (11/21):\n", + " Subset 0: () gives pval = 0.12671 / val = -0.586\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V4 (12/21):\n", + " Subset 0: () gives pval = 0.87499 / val = -0.067\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V4 (13/21):\n", + " Subset 0: () gives pval = 0.45958 / val = -0.307\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V4 (14/21):\n", + " Subset 0: () gives pval = 0.72738 / val = -0.148\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V4 (15/21):\n", + " Subset 0: () gives pval = 0.29395 / val = -0.425\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V4 (16/21):\n", + " Subset 0: () gives pval = 0.88424 / val = 0.062\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V4 (17/21):\n", + " Subset 0: () gives pval = 0.17711 / val = 0.530\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V4 (18/21):\n", + " Subset 0: () gives pval = 0.81886 / val = 0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V4 (19/21):\n", + " Subset 0: () gives pval = 0.80817 / val = 0.103\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V4 (20/21):\n", + " Subset 0: () gives pval = 0.93921 / val = 0.032\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V4 (21/21):\n", + " Subset 0: () gives pval = 0.21585 / val = 0.492\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V4\n", + "\n", + "## Variable V5\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V5 (1/21):\n", + " Subset 0: () gives pval = 0.37886 / val = -0.362\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V5 (2/21):\n", + " Subset 0: () gives pval = 0.30644 / val = 0.415\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V5 (3/21):\n", + " Subset 0: () gives pval = 0.73999 / val = -0.141\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V5 (4/21):\n", + " Subset 0: () gives pval = 0.95989 / val = -0.021\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V5 (5/21):\n", + " Subset 0: () gives pval = 0.72633 / val = 0.148\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V5 (6/21):\n", + " Subset 0: () gives pval = 0.80597 / val = -0.104\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V5 (7/21):\n", + " Subset 0: () gives pval = 0.42170 / val = 0.332\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V5 (8/21):\n", + " Subset 0: () gives pval = 0.70342 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V5 (9/21):\n", + " Subset 0: () gives pval = 0.16043 / val = -0.547\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V5 (10/21):\n", + " Subset 0: () gives pval = 0.85612 / val = 0.077\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V5 (11/21):\n", + " Subset 0: () gives pval = 0.71488 / val = 0.155\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V5 (12/21):\n", + " Subset 0: () gives pval = 0.74776 / val = -0.136\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V5 (13/21):\n", + " Subset 0: () gives pval = 0.12982 / val = -0.582\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V5 (14/21):\n", + " Subset 0: () gives pval = 0.36498 / val = 0.371\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V5 (15/21):\n", + " Subset 0: () gives pval = 0.40910 / val = -0.341\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V5 (16/21):\n", + " Subset 0: () gives pval = 0.38906 / val = -0.354\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V5 (17/21):\n", + " Subset 0: () gives pval = 0.12547 / val = 0.588\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V5 (18/21):\n", + " Subset 0: () gives pval = 0.73154 / val = -0.145\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V5 (19/21):\n", + " Subset 0: () gives pval = 0.94756 / val = 0.028\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V5 (20/21):\n", + " Subset 0: () gives pval = 0.47394 / val = -0.298\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V5 (21/21):\n", + " Subset 0: () gives pval = 0.19310 / val = 0.513\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V5\n", + "\n", + "## Variable V6\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V6 (1/21):\n", + " Subset 0: () gives pval = 0.38954 / val = 0.354\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V6 (2/21):\n", + " Subset 0: () gives pval = 0.13823 / val = 0.572\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V6 (3/21):\n", + " Subset 0: () gives pval = 0.13173 / val = -0.580\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V6 (4/21):\n", + " Subset 0: () gives pval = 0.45705 / val = -0.309\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V6 (5/21):\n", + " Subset 0: () gives pval = 0.59135 / val = 0.225\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V6 (6/21):\n", + " Subset 0: () gives pval = 0.46932 / val = 0.301\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V6 (7/21):\n", + " Subset 0: () gives pval = 0.19069 / val = -0.516\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V6 (8/21):\n", + " Subset 0: () gives pval = 0.81980 / val = 0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V6 (9/21):\n", + " Subset 0: () gives pval = 0.92754 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V6 (10/21):\n", + " Subset 0: () gives pval = 0.79337 / val = -0.111\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V6 (11/21):\n", + " Subset 0: () gives pval = 0.42452 / val = -0.330\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V6 (12/21):\n", + " Subset 0: () gives pval = 0.11568 / val = -0.600\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V6 (13/21):\n", + " Subset 0: () gives pval = 0.26711 / val = -0.447\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V6 (14/21):\n", + " Subset 0: () gives pval = 0.73415 / val = -0.144\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V6 (15/21):\n", + " Subset 0: () gives pval = 0.89556 / val = 0.056\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V6 (16/21):\n", + " Subset 0: () gives pval = 0.59685 / val = 0.222\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V6 (17/21):\n", + " Subset 0: () gives pval = 0.75751 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V6 (18/21):\n", + " Subset 0: () gives pval = 0.41015 / val = -0.340\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V6 (19/21):\n", + " Subset 0: () gives pval = 0.00000 / val = 0.992\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V7 -2) -?> V6 (20/21):\n", + " Subset 0: () gives pval = 0.48406 / val = 0.291\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V6 (21/21):\n", + " Subset 0: () gives pval = 0.81090 / val = -0.102\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", + "\n", + "Algorithm converged for variable V6\n", + "\n", + "## Variable V7\n", + "\n", + "Iterating through pc_alpha = [0.025]:\n", + "\n", + "# pc_alpha = 0.025 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V7 (1/21):\n", + " Subset 0: () gives pval = 0.10602 / val = 0.613\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V7 (2/21):\n", + " Subset 0: () gives pval = 0.13143 / val = -0.580\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V7 (3/21):\n", + " Subset 0: () gives pval = 0.20399 / val = -0.503\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V7 (4/21):\n", + " Subset 0: () gives pval = 0.31711 / val = 0.407\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V7 (5/21):\n", + " Subset 0: () gives pval = 0.40496 / val = 0.343\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V7 (6/21):\n", + " Subset 0: () gives pval = 0.49089 / val = -0.287\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V7 (7/21):\n", + " Subset 0: () gives pval = 0.92032 / val = 0.043\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V7 (8/21):\n", + " Subset 0: () gives pval = 0.79775 / val = -0.109\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V7 (9/21):\n", + " Subset 0: () gives pval = 0.75377 / val = 0.133\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V7 (10/21):\n", + " Subset 0: () gives pval = 0.75703 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V7 (11/21):\n", + " Subset 0: () gives pval = 0.07150 / val = -0.666\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V7 (12/21):\n", + " Subset 0: () gives pval = 0.87683 / val = 0.066\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V7 (13/21):\n", + " Subset 0: () gives pval = 0.97094 / val = 0.016\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V7 (14/21):\n", + " Subset 0: () gives pval = 0.62396 / val = -0.206\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V7 (15/21):\n", + " Subset 0: () gives pval = 0.16865 / val = 0.538\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V7 (16/21):\n", + " Subset 0: () gives pval = 0.98554 / val = -0.008\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V7 (17/21):\n", + " Subset 0: () gives pval = 0.90824 / val = -0.049\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V7 (18/21):\n", + " Subset 0: () gives pval = 0.13870 / val = 0.572\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V7 (19/21):\n", + " Subset 0: () gives pval = 0.50733 / val = 0.277\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V7 (20/21):\n", + " Subset 0: () gives pval = 0.93834 / val = 0.033\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V7 (21/21):\n", + " Subset 0: () gives pval = 0.92994 / val = -0.037\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V7\n", + "\n", + "## Resulting lagged parent (super)sets:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "##\n", + "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", + "##\n", + "\n", + "Parameters:\n", + "\n", + "independence test = par_corr\n", + "tau_min = 0\n", + "tau_max = 3\n", + "pc_alpha = 0.025\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "reset_lagged_links = False\n", + "max_conds_dim = None\n", + "max_conds_py = None\n", + "max_conds_px = None\n", + "max_conds_px_lagged = None\n", + "fdr_method = none\n", + "\n", + "--------------------------\n", + "Skeleton discovery phase\n", + "--------------------------\n", + "\n", + "Testing contemporaneous condition sets of dimension 0: \n", + "\n", + " Link (V1 0) o?o V2 (1/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V2 -2) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.78838 / val = 0.126\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V3 (2/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.96748 / val = 0.017\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V4 (3/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.39632 / val = 0.349\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V5 (4/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.89723 / val = 0.055\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V6 (5/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.46578 / val = -0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V7 (6/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.32813 / val = 0.399\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V1 (7/44):\n", + " Already removed.\n", + "\n", + " Link (V2 -2) -?> V2 (8/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -4) ]\n", + " Subset 0: () gives pval = 0.00773 / val = -0.887\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V2 0) o?o V3 (9/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.11874 / val = -0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V4 (10/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.64856 / val = 0.212\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V5 (11/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.33073 / val = 0.434\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V6 (12/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.49710 / val = 0.349\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V7 (13/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.93791 / val = -0.037\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V1 (14/44):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V2 (15/44):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V4 (16/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.30341 / val = 0.417\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V5 (17/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.95447 / val = 0.024\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V6 (18/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.53674 / val = -0.284\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V7 (19/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.25153 / val = -0.460\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V1 (20/44):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V2 (21/44):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V3 (22/44):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V5 (23/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.20930 / val = 0.498\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V6 (24/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.26768 / val = -0.487\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V7 (25/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.92759 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V1 (26/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V2 (27/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V3 (28/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V4 (29/44):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V6 (30/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.38468 / val = 0.392\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V7 (31/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.32066 / val = -0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V6 0) o?o V1 (32/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V2 (33/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V3 (34/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V4 (35/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V5 (36/44):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V7 (37/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V7 -1) ]\n", + " Subset 0: () gives pval = 0.09642 / val = -0.675\n", + " Non-significance detected.\n", + "\n", + " Link (V7 0) o?o V1 (38/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V2 (39/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V3 (40/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V4 (41/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V5 (42/44):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V6 (43/44):\n", + " Already removed.\n", + "\n", + " Link (V7 -1) -?> V6 (44/44):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.00000 / val = 0.992\n", + " No conditions of dimension 0 left.\n", + "\n", + "Updated contemp. adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged at p = 0.\n", + "\n", + "----------------------------\n", + "Collider orientation phase\n", + "----------------------------\n", + "\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2)\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1)\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "\n", + "----------------------------\n", + "Rule orientation phase\n", + "----------------------------\n", + "\n", + "Try rule(s) [1 2 3]\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2)\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1)\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## Significant links at alpha = 0.025:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): pval = 0.00773 | val = -0.887\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): pval = 0.00000 | val = 0.992\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## pc_alpha = 0.05 (5/5):\n", + "\n", + "##\n", + "## Step 1: PC1 algorithm for selecting lagged conditions\n", + "##\n", + "\n", + "Parameters:\n", + "independence test = par_corr\n", + "tau_min = 1\n", + "tau_max = 3\n", + "pc_alpha = [0.05]\n", + "max_conds_dim = None\n", + "max_combinations = 1\n", + "\n", + "\n", + "\n", + "## Variable V1\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V1 (1/21):\n", + " Subset 0: () gives pval = 0.86601 / val = -0.072\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V1 (2/21):\n", + " Subset 0: () gives pval = 0.57469 / val = -0.235\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V1 (3/21):\n", + " Subset 0: () gives pval = 0.13528 / val = -0.576\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V1 (4/21):\n", + " Subset 0: () gives pval = 0.08631 / val = 0.642\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V1 (5/21):\n", + " Subset 0: () gives pval = 1.00000 / val = -0.000\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V1 (6/21):\n", + " Subset 0: () gives pval = 0.08260 / val = -0.647\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V1 (7/21):\n", + " Subset 0: () gives pval = 0.30492 / val = -0.416\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V1 (8/21):\n", + " Subset 0: () gives pval = 0.90322 / val = -0.052\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V1 (9/21):\n", + " Subset 0: () gives pval = 0.59372 / val = 0.224\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V1 (10/21):\n", + " Subset 0: () gives pval = 0.08508 / val = -0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V1 (11/21):\n", + " Subset 0: () gives pval = 0.21081 / val = -0.496\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V1 (12/21):\n", + " Subset 0: () gives pval = 0.26642 / val = 0.447\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V1 (13/21):\n", + " Subset 0: () gives pval = 0.36475 / val = -0.372\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V1 (14/21):\n", + " Subset 0: () gives pval = 0.97472 / val = -0.013\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V1 (15/21):\n", + " Subset 0: () gives pval = 0.28630 / val = 0.431\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V1 (16/21):\n", + " Subset 0: () gives pval = 0.69615 / val = -0.165\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V1 (17/21):\n", + " Subset 0: () gives pval = 0.60470 / val = 0.218\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V1 (18/21):\n", + " Subset 0: () gives pval = 0.64103 / val = 0.196\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V1 (19/21):\n", + " Subset 0: () gives pval = 0.32015 / val = 0.405\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V1 (20/21):\n", + " Subset 0: () gives pval = 0.67332 / val = -0.178\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V1 (21/21):\n", + " Subset 0: () gives pval = 0.52668 / val = 0.265\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V1\n", + "\n", + "## Variable V2\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V2 (1/21):\n", + " Subset 0: () gives pval = 0.12317 / val = -0.591\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V2 (2/21):\n", + " Subset 0: () gives pval = 0.87304 / val = 0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V2 (3/21):\n", + " Subset 0: () gives pval = 0.40658 / val = 0.342\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V2 (4/21):\n", + " Subset 0: () gives pval = 0.87285 / val = -0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V2 (5/21):\n", + " Subset 0: () gives pval = 0.00058 / val = -0.938\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V2 -3) -?> V2 (6/21):\n", + " Subset 0: () gives pval = 0.38647 / val = 0.356\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V2 (7/21):\n", + " Subset 0: () gives pval = 0.18843 / val = -0.518\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V2 (8/21):\n", + " Subset 0: () gives pval = 0.82124 / val = 0.096\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V2 (9/21):\n", + " Subset 0: () gives pval = 0.25844 / val = 0.454\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V2 (10/21):\n", + " Subset 0: () gives pval = 0.08165 / val = -0.649\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V2 (11/21):\n", + " Subset 0: () gives pval = 0.06607 / val = 0.675\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V2 (12/21):\n", + " Subset 0: () gives pval = 0.58825 / val = 0.227\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V2 (13/21):\n", + " Subset 0: () gives pval = 0.38186 / val = -0.359\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V2 (14/21):\n", + " Subset 0: () gives pval = 0.32916 / val = 0.398\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V2 (15/21):\n", + " Subset 0: () gives pval = 0.98847 / val = 0.006\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V2 (16/21):\n", + " Subset 0: () gives pval = 0.32076 / val = 0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V2 (17/21):\n", + " Subset 0: () gives pval = 0.40538 / val = 0.343\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V2 (18/21):\n", + " Subset 0: () gives pval = 0.37909 / val = -0.361\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V2 (19/21):\n", + " Subset 0: () gives pval = 0.96874 / val = -0.017\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V2 (20/21):\n", + " Subset 0: () gives pval = 0.29908 / val = 0.421\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V2 (21/21):\n", + " Subset 0: () gives pval = 0.32576 / val = 0.400\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", + "\n", + "Algorithm converged for variable V2\n", + "\n", + "## Variable V3\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V3 (1/21):\n", + " Subset 0: () gives pval = 0.39391 / val = -0.351\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V3 (2/21):\n", + " Subset 0: () gives pval = 0.75698 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V3 (3/21):\n", + " Subset 0: () gives pval = 0.17237 / val = 0.534\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V3 (4/21):\n", + " Subset 0: () gives pval = 0.25198 / val = 0.460\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V3 (5/21):\n", + " Subset 0: () gives pval = 0.81987 / val = -0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V3 (6/21):\n", + " Subset 0: () gives pval = 0.14919 / val = -0.560\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V3 (7/21):\n", + " Subset 0: () gives pval = 0.92814 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V3 (8/21):\n", + " Subset 0: () gives pval = 0.55198 / val = -0.249\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V3 (9/21):\n", + " Subset 0: () gives pval = 0.87647 / val = -0.066\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V3 (10/21):\n", + " Subset 0: () gives pval = 0.83660 / val = 0.088\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V3 (11/21):\n", + " Subset 0: () gives pval = 0.92891 / val = 0.038\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V3 (12/21):\n", + " Subset 0: () gives pval = 0.18176 / val = 0.525\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V3 (13/21):\n", + " Subset 0: () gives pval = 0.32210 / val = 0.403\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V3 (14/21):\n", + " Subset 0: () gives pval = 0.67508 / val = -0.177\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V3 (15/21):\n", + " Subset 0: () gives pval = 0.65106 / val = -0.191\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V3 (16/21):\n", + " Subset 0: () gives pval = 0.87265 / val = -0.068\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V3 (17/21):\n", + " Subset 0: () gives pval = 0.73304 / val = 0.144\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V3 (18/21):\n", + " Subset 0: () gives pval = 0.71062 / val = 0.157\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V3 (19/21):\n", + " Subset 0: () gives pval = 0.08132 / val = -0.650\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V3 (20/21):\n", + " Subset 0: () gives pval = 0.65185 / val = -0.190\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V3 (21/21):\n", + " Subset 0: () gives pval = 0.71587 / val = 0.154\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V3\n", + "\n", + "## Variable V4\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V4 (1/21):\n", + " Subset 0: () gives pval = 0.56354 / val = 0.242\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V4 (2/21):\n", + " Subset 0: () gives pval = 0.58558 / val = 0.229\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V4 (3/21):\n", + " Subset 0: () gives pval = 0.96166 / val = -0.020\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V4 (4/21):\n", + " Subset 0: () gives pval = 0.16299 / val = 0.544\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V4 (5/21):\n", + " Subset 0: () gives pval = 0.24064 / val = 0.469\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V4 (6/21):\n", + " Subset 0: () gives pval = 0.06141 / val = -0.684\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V4 (7/21):\n", + " Subset 0: () gives pval = 0.94919 / val = 0.027\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V4 (8/21):\n", + " Subset 0: () gives pval = 0.02698 / val = -0.765\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V3 -3) -?> V4 (9/21):\n", + " Subset 0: () gives pval = 0.35707 / val = -0.377\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V4 (10/21):\n", + " Subset 0: () gives pval = 0.77024 / val = 0.124\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V4 (11/21):\n", + " Subset 0: () gives pval = 0.12671 / val = -0.586\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V4 (12/21):\n", + " Subset 0: () gives pval = 0.87499 / val = -0.067\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V4 (13/21):\n", + " Subset 0: () gives pval = 0.45958 / val = -0.307\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V4 (14/21):\n", + " Subset 0: () gives pval = 0.72738 / val = -0.148\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V4 (15/21):\n", + " Subset 0: () gives pval = 0.29395 / val = -0.425\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V4 (16/21):\n", + " Subset 0: () gives pval = 0.88424 / val = 0.062\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V4 (17/21):\n", + " Subset 0: () gives pval = 0.17711 / val = 0.530\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V4 (18/21):\n", + " Subset 0: () gives pval = 0.81886 / val = 0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V4 (19/21):\n", + " Subset 0: () gives pval = 0.80817 / val = 0.103\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V4 (20/21):\n", + " Subset 0: () gives pval = 0.93921 / val = 0.032\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V4 (21/21):\n", + " Subset 0: () gives pval = 0.21585 / val = 0.492\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V4 has 1 link(s):\n", + " (V3 -2): max_pval = 0.02698, |min_val| = 0.765\n", + "\n", + "Algorithm converged for variable V4\n", + "\n", + "## Variable V5\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V5 (1/21):\n", + " Subset 0: () gives pval = 0.37886 / val = -0.362\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V5 (2/21):\n", + " Subset 0: () gives pval = 0.30644 / val = 0.415\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V5 (3/21):\n", + " Subset 0: () gives pval = 0.73999 / val = -0.141\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V5 (4/21):\n", + " Subset 0: () gives pval = 0.95989 / val = -0.021\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V5 (5/21):\n", + " Subset 0: () gives pval = 0.72633 / val = 0.148\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V5 (6/21):\n", + " Subset 0: () gives pval = 0.80597 / val = -0.104\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V5 (7/21):\n", + " Subset 0: () gives pval = 0.42170 / val = 0.332\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V5 (8/21):\n", + " Subset 0: () gives pval = 0.70342 / val = -0.161\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V5 (9/21):\n", + " Subset 0: () gives pval = 0.16043 / val = -0.547\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V5 (10/21):\n", + " Subset 0: () gives pval = 0.85612 / val = 0.077\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V5 (11/21):\n", + " Subset 0: () gives pval = 0.71488 / val = 0.155\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V5 (12/21):\n", + " Subset 0: () gives pval = 0.74776 / val = -0.136\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V5 (13/21):\n", + " Subset 0: () gives pval = 0.12982 / val = -0.582\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V5 (14/21):\n", + " Subset 0: () gives pval = 0.36498 / val = 0.371\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V5 (15/21):\n", + " Subset 0: () gives pval = 0.40910 / val = -0.341\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V5 (16/21):\n", + " Subset 0: () gives pval = 0.38906 / val = -0.354\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V5 (17/21):\n", + " Subset 0: () gives pval = 0.12547 / val = 0.588\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V5 (18/21):\n", + " Subset 0: () gives pval = 0.73154 / val = -0.145\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V5 (19/21):\n", + " Subset 0: () gives pval = 0.94756 / val = 0.028\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V5 (20/21):\n", + " Subset 0: () gives pval = 0.47394 / val = -0.298\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V5 (21/21):\n", + " Subset 0: () gives pval = 0.19310 / val = 0.513\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V5\n", + "\n", + "## Variable V6\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V6 (1/21):\n", + " Subset 0: () gives pval = 0.38954 / val = 0.354\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V6 (2/21):\n", + " Subset 0: () gives pval = 0.13823 / val = 0.572\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V6 (3/21):\n", + " Subset 0: () gives pval = 0.13173 / val = -0.580\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V6 (4/21):\n", + " Subset 0: () gives pval = 0.45705 / val = -0.309\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V6 (5/21):\n", + " Subset 0: () gives pval = 0.59135 / val = 0.225\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V6 (6/21):\n", + " Subset 0: () gives pval = 0.46932 / val = 0.301\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V6 (7/21):\n", + " Subset 0: () gives pval = 0.19069 / val = -0.516\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V6 (8/21):\n", + " Subset 0: () gives pval = 0.81980 / val = 0.097\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V6 (9/21):\n", + " Subset 0: () gives pval = 0.92754 / val = -0.039\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V6 (10/21):\n", + " Subset 0: () gives pval = 0.79337 / val = -0.111\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V6 (11/21):\n", + " Subset 0: () gives pval = 0.42452 / val = -0.330\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V6 (12/21):\n", + " Subset 0: () gives pval = 0.11568 / val = -0.600\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V6 (13/21):\n", + " Subset 0: () gives pval = 0.26711 / val = -0.447\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V6 (14/21):\n", + " Subset 0: () gives pval = 0.73415 / val = -0.144\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V6 (15/21):\n", + " Subset 0: () gives pval = 0.89556 / val = 0.056\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V6 (16/21):\n", + " Subset 0: () gives pval = 0.59685 / val = 0.222\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V6 (17/21):\n", + " Subset 0: () gives pval = 0.75751 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V6 (18/21):\n", + " Subset 0: () gives pval = 0.41015 / val = -0.340\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V6 (19/21):\n", + " Subset 0: () gives pval = 0.00000 / val = 0.992\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V7 -2) -?> V6 (20/21):\n", + " Subset 0: () gives pval = 0.48406 / val = 0.291\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V6 (21/21):\n", + " Subset 0: () gives pval = 0.81090 / val = -0.102\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", + "\n", + "Algorithm converged for variable V6\n", + "\n", + "## Variable V7\n", + "\n", + "Iterating through pc_alpha = [0.05]:\n", + "\n", + "# pc_alpha = 0.05 (1/1):\n", + "\n", + "Testing condition sets of dimension 0:\n", + "\n", + " Link (V1 -1) -?> V7 (1/21):\n", + " Subset 0: () gives pval = 0.10602 / val = 0.613\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -2) -?> V7 (2/21):\n", + " Subset 0: () gives pval = 0.13143 / val = -0.580\n", + " Non-significance detected.\n", + "\n", + " Link (V1 -3) -?> V7 (3/21):\n", + " Subset 0: () gives pval = 0.20399 / val = -0.503\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -1) -?> V7 (4/21):\n", + " Subset 0: () gives pval = 0.31711 / val = 0.407\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -2) -?> V7 (5/21):\n", + " Subset 0: () gives pval = 0.40496 / val = 0.343\n", + " Non-significance detected.\n", + "\n", + " Link (V2 -3) -?> V7 (6/21):\n", + " Subset 0: () gives pval = 0.49089 / val = -0.287\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -1) -?> V7 (7/21):\n", + " Subset 0: () gives pval = 0.92032 / val = 0.043\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V7 (8/21):\n", + " Subset 0: () gives pval = 0.79775 / val = -0.109\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -3) -?> V7 (9/21):\n", + " Subset 0: () gives pval = 0.75377 / val = 0.133\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -1) -?> V7 (10/21):\n", + " Subset 0: () gives pval = 0.75703 / val = -0.131\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -2) -?> V7 (11/21):\n", + " Subset 0: () gives pval = 0.07150 / val = -0.666\n", + " Non-significance detected.\n", + "\n", + " Link (V4 -3) -?> V7 (12/21):\n", + " Subset 0: () gives pval = 0.87683 / val = 0.066\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -1) -?> V7 (13/21):\n", + " Subset 0: () gives pval = 0.97094 / val = 0.016\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -2) -?> V7 (14/21):\n", + " Subset 0: () gives pval = 0.62396 / val = -0.206\n", + " Non-significance detected.\n", + "\n", + " Link (V5 -3) -?> V7 (15/21):\n", + " Subset 0: () gives pval = 0.16865 / val = 0.538\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -1) -?> V7 (16/21):\n", + " Subset 0: () gives pval = 0.98554 / val = -0.008\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -2) -?> V7 (17/21):\n", + " Subset 0: () gives pval = 0.90824 / val = -0.049\n", + " Non-significance detected.\n", + "\n", + " Link (V6 -3) -?> V7 (18/21):\n", + " Subset 0: () gives pval = 0.13870 / val = 0.572\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -1) -?> V7 (19/21):\n", + " Subset 0: () gives pval = 0.50733 / val = 0.277\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -2) -?> V7 (20/21):\n", + " Subset 0: () gives pval = 0.93834 / val = 0.033\n", + " Non-significance detected.\n", + "\n", + " Link (V7 -3) -?> V7 (21/21):\n", + " Subset 0: () gives pval = 0.92994 / val = -0.037\n", + " Non-significance detected.\n", + "\n", + " Sorting parents in decreasing order with \n", + " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", + "\n", + "Updating parents:\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged for variable V7\n", + "\n", + "## Resulting lagged parent (super)sets:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 1 link(s):\n", + " (V3 -2): max_pval = 0.02698, |min_val| = 0.765\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "##\n", + "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", + "##\n", + "\n", + "Parameters:\n", + "\n", + "independence test = par_corr\n", + "tau_min = 0\n", + "tau_max = 3\n", + "pc_alpha = 0.05\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "reset_lagged_links = False\n", + "max_conds_dim = None\n", + "max_conds_py = None\n", + "max_conds_px = None\n", + "max_conds_px_lagged = None\n", + "fdr_method = none\n", + "\n", + "--------------------------\n", + "Skeleton discovery phase\n", + "--------------------------\n", + "\n", + "Testing contemporaneous condition sets of dimension 0: \n", + "\n", + " Link (V1 0) o?o V2 (1/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V2 -2) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.78838 / val = 0.126\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V3 (2/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.96748 / val = 0.017\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V4 (3/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V3 -2) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.27373 / val = 0.482\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V5 (4/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.89723 / val = 0.055\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V6 (5/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.46578 / val = -0.333\n", + " Non-significance detected.\n", + "\n", + " Link (V1 0) o?o V7 (6/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.32813 / val = 0.399\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V1 (7/45):\n", + " Already removed.\n", + "\n", + " Link (V2 -2) -?> V2 (8/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -4) ]\n", + " Subset 0: () gives pval = 0.00773 / val = -0.887\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V2 0) o?o V3 (9/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.11874 / val = -0.644\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V4 (10/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V3 -2) ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.95232 / val = 0.032\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V5 (11/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.33073 / val = 0.434\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V6 (12/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.49710 / val = 0.349\n", + " Non-significance detected.\n", + "\n", + " Link (V2 0) o?o V7 (13/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V2 -2) ]\n", + " Subset 0: () gives pval = 0.93791 / val = -0.037\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V1 (14/45):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V2 (15/45):\n", + " Already removed.\n", + "\n", + " Link (V3 0) o?o V4 (16/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V3 -2) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.42232 / val = 0.364\n", + " Non-significance detected.\n", + "\n", + " Link (V3 -2) -?> V4 (17/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.02698 / val = -0.765\n", + " No conditions of dimension 0 left.\n", + "\n", + " Link (V3 0) o?o V5 (18/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.95447 / val = 0.024\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V6 (19/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.53674 / val = -0.284\n", + " Non-significance detected.\n", + "\n", + " Link (V3 0) o?o V7 (20/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.25153 / val = -0.460\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V1 (21/45):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V2 (22/45):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V3 (23/45):\n", + " Already removed.\n", + "\n", + " Link (V4 0) o?o V5 (24/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V3 -2) ]\n", + " Subset 0: () gives pval = 0.16356 / val = 0.590\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V6 (25/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ (V3 -2) ]\n", + " Subset 0: () gives pval = 0.84717 / val = -0.102\n", + " Non-significance detected.\n", + "\n", + " Link (V4 0) o?o V7 (26/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V3 -2) ]\n", + " Subset 0: () gives pval = 0.68274 / val = -0.190\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V1 (27/45):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V2 (28/45):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V3 (29/45):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V4 (30/45):\n", + " Already removed.\n", + "\n", + " Link (V5 0) o?o V6 (31/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ (V7 -1) ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.38468 / val = 0.392\n", + " Non-significance detected.\n", + "\n", + " Link (V5 0) o?o V7 (32/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.32066 / val = -0.404\n", + " Non-significance detected.\n", + "\n", + " Link (V6 0) o?o V1 (33/45):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V2 (34/45):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V3 (35/45):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V4 (36/45):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V5 (37/45):\n", + " Already removed.\n", + "\n", + " Link (V6 0) o?o V7 (38/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ (V7 -1) ]\n", + " Subset 0: () gives pval = 0.09642 / val = -0.675\n", + " Non-significance detected.\n", + "\n", + " Link (V7 0) o?o V1 (39/45):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V2 (40/45):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V3 (41/45):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V4 (42/45):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V5 (43/45):\n", + " Already removed.\n", + "\n", + " Link (V7 0) o?o V6 (44/45):\n", + " Already removed.\n", + "\n", + " Link (V7 -1) -?> V6 (45/45):\n", + " Iterate through 1 subset(s) of conditions: \n", + " with conds_y = [ ]\n", + " with conds_x = [ ]\n", + " Subset 0: () gives pval = 0.00000 / val = 0.992\n", + " No conditions of dimension 0 left.\n", + "\n", + "Updated contemp. adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 0 link(s):\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 0 link(s):\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 0 link(s):\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "Algorithm converged at p = 0.\n", + "\n", + "----------------------------\n", + "Collider orientation phase\n", + "----------------------------\n", + "\n", + "contemp_collider_rule = majority\n", + "conflict_resolution = True\n", + "\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2)\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 1 link(s):\n", + " (V3 -2)\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1)\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "\n", + "----------------------------\n", + "Rule orientation phase\n", + "----------------------------\n", + "\n", + "Try rule(s) [1 2 3]\n", + "\n", + "Updated adjacencies:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2)\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 1 link(s):\n", + " (V3 -2)\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1)\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "## Significant links at alpha = 0.05:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): pval = 0.00773 | val = -0.887\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 1 link(s):\n", + " (V3 -2): pval = 0.02698 | val = -0.765\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): pval = 0.00000 | val = 0.992\n", + "\n", + " Variable V7 has 0 link(s):\n", + "\n", + "##\n", + "\n", + "## Scores for individual pc_alpha values:\n", + "\n", + " pc_alpha = 0.001 yields score = 14.18332\n", + " pc_alpha = 0.005 yields score = 14.18332\n", + " pc_alpha = 0.01 yields score = 12.05241\n", + " pc_alpha = 0.025 yields score = 12.05241\n", + " pc_alpha = 0.05 yields score = 11.33224\n", + "\n", + "##\n", + "## Results for optimal pc_alpha = 0.05\n", + "##\n", + "\n", + "## Significant links at alpha = 0.05:\n", + "\n", + " Variable V1 has 0 link(s):\n", + "\n", + " Variable V2 has 1 link(s):\n", + " (V2 -2): pval = 0.00773 | val = -0.887\n", + "\n", + " Variable V3 has 0 link(s):\n", + "\n", + " Variable V4 has 1 link(s):\n", + " (V3 -2): pval = 0.02698 | val = -0.765\n", + "\n", + " Variable V5 has 0 link(s):\n", + "\n", + " Variable V6 has 1 link(s):\n", + " (V7 -1): pval = 0.00000 | val = 0.992\n", + "\n", + " Variable V7 has 0 link(s):\n" + ] + } + ], "source": [ "tau_max = 3\n", "pc_alpha = None\n", @@ -261,9 +5946,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from dowhy.utils.timeseries import create_graph_from_networkx_array\n", "\n", diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 414d63b71..58c2e0b19 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -65,6 +65,13 @@ def add_lagged_edges(graph: nx.DiGraph, start_node: str) -> nx.DiGraph: else: lagged_node_mapping[parent] = new_lagged_nodes + for original_node, lagged_nodes in lagged_node_mapping.items(): + sorted_lagged_nodes = sorted(lagged_nodes, key=lambda x: int(x.split('_')[-1])) + for i in range(len(sorted_lagged_nodes) - 1): + lesser_lagged_node = sorted_lagged_nodes[i] + more_lagged_node = sorted_lagged_nodes[i + 1] + new_graph.add_edge(lesser_lagged_node, more_lagged_node) + return new_graph From 04adfb69a2001fcc43ca433fd433d34918e80352 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 2 Aug 2024 08:55:46 +0000 Subject: [PATCH 63/67] clear outputs & formatting --- .../effect_inference_timeseries_data.ipynb | 5754 +---------------- 1 file changed, 29 insertions(+), 5725 deletions(-) diff --git a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index c622ca293..8f2eb41d6 100644 --- a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -30,12 +30,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# read the dataframe in a csv format from the user\n", "dataset_path=\"../datasets/temporal_dataset.csv\"\n", + "\n", "dataframe=pd.read_csv(dataset_path)" ] }, @@ -43,27 +43,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In temporal causal inference, accurately estimating causal effects often requires accounting for time lags between nodes in a graph. For instance, if $node_1$ influences $node_2$ with a time lag of 5 timestamps, we represent this dependency as $node_1(t-5)$ -> $node_2(t)$.\n", + "In temporal causal inference, accurately estimating causal effects often requires accounting for time lags between nodes in a graph. For instance, if $node_1$ influences $node_2$ with a time lag of 5 timestamps, we represent this dependency as $node_1^{t-5}$ -> $node_2^{t}$.\n", "\n", - "We can provide the causal graph as a networkx DAG or as a dot file. The edge attributes should mention the maximum `time_lag` that is associated with each edge (if any)." + "We can provide the causal graph as a networkx DAG or as a dot file. The edge attributes should mention the exact `time_lag` that is associated with each edge (if any)." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from dowhy.utils.timeseries import create_graph_from_dot_format\n", "\n", @@ -92,20 +81,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Input a csv file with the edges in the graph with the columns: node_1,node_2,time_lag\n", "file_path = \"../datasets/temporal_graph.csv\"\n", @@ -123,12 +101,12 @@ "\n", "To prepare the dataset for temporal causal inference, we need to shift the columns by the given time lag.\n", "\n", - "For example, in the causal graph above, $node_1(t-3)$ -> $node_2(t)$ with a lag of 3. When considering $node_2$ as the target node, the data for $node_1$ should be shifted down by 3 timestamps. This adjustment ensures that the edge $node_1$ -> $node_2$ accurately represents the lagged dependency. Shifting the data in this manner creates additional columns and allows downstream estimators to acccess the correct values in the same row of a dataframe. " + "For example, in the causal graph above, $node_1^{t-5}$ -> $node_2^{t}$ with a lag of 5. When considering $node_2$ as the target node, the data for $node_1$ should be shifted down by 5 timestamps. This adjustment ensures that the edge $node_1$ -> $node_2$ accurately represents the lagged dependency. Shifting the data in this manner creates additional columns and allows downstream estimators to acccess the correct values in the same row of a dataframe. " ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -137,20 +115,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# the outcome node for which effect estimation has to be done, node:6\n", "target_node = 'V6'\n", @@ -160,108 +127,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
V6_0V5_-1V7_-3V7_-5V4_-3V4_-7V4_-9
06000000
17500000
28600000
39770400
49880500
\n", - "
" - ], - "text/plain": [ - " V6_0 V5_-1 V7_-3 V7_-5 V4_-3 V4_-7 V4_-9\n", - "0 6 0 0 0 0 0 0\n", - "1 7 5 0 0 0 0 0\n", - "2 8 6 0 0 0 0 0\n", - "3 9 7 7 0 4 0 0\n", - "4 9 8 8 0 5 0 0" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "time_shifted_df = shift_columns_by_lag_using_unrolled_graph(dataframe, unrolled_graph)\n", "time_shifted_df.head()" @@ -278,20 +146,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['V5_-1', 'V7_-3', 'V7_-5', 'V4_-3', 'V4_-7', 'V4_-9']" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "target_node = 'V6_0'\n", "# include all the treatments\n", @@ -302,78 +159,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "*** Causal Estimate ***\n", - "\n", - "## Identified estimand\n", - "Estimand type: EstimandType.NONPARAMETRIC_ATE\n", - "\n", - "### Estimand : 1\n", - "Estimand name: backdoor\n", - "Estimand expression:\n", - " d \n", - "────────(E[V_6_0|V4_-7])\n", - "d[V₅ ₋₁] \n", - "Estimand assumption 1, Unconfoundedness: If U→{V5_-1} and U→V6_0 then P(V6_0|V5_-1,V4_-7,U) = P(V6_0|V5_-1,V4_-7)\n", - "\n", - "## Realized estimand\n", - "b: V6_0~V5_-1+V4_-7+V5_-1*V7_-3+V5_-1*V7_-5\n", - "Target units: \n", - "\n", - "## Estimate\n", - "Mean value: -0.12612138021763197\n", - "p-value: [0.75401158]\n", - "### Conditional Estimates\n", - "__categorical__V7_-3 __categorical__V7_-5\n", - "(-0.001, 0.6] (-0.001, 5.4] 0.111915\n", - "(0.6, 5.4] (7.8, 9.0] -0.257861\n", - " (9.0, 10.0] -0.314176\n", - "(5.4, 7.8] (-0.001, 5.4] 0.073537\n", - " (7.8, 9.0] -0.285273\n", - "(7.8, 9.0] (-0.001, 5.4] -0.034356\n", - " (5.4, 7.8] -0.216503\n", - " (7.8, 9.0] -0.296238\n", - "(9.0, 10.0] (7.8, 9.0] -0.261853\n", - "dtype: float64\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/t-ashutoshs/miniconda3/envs/env_dowhy/lib/python3.10/site-packages/scipy/stats/_axis_nan_policy.py:531: UserWarning: kurtosistest only valid for n>=20 ... continuing anyway, n=14\n", - " res = hypotest_fun_out(*samples, **kwds)\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimator.py:266: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", - " by_effect_mods = data.groupby(effect_modifier_names)\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n", - "/home/t-ashutoshs/home/dowhy/dowhy/causal_estimators/regression_estimator.py:131: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " intercept_parameter = self.model.params[0]\n" - ] - } - ], + "outputs": [], "source": [ "# perform causal effect estimation on this new dataset\n", "import dowhy\n", @@ -407,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -424,20 +212,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from tigramite import plotting as tp\n", "tp.plot_timeseries(dataframe, figsize=(15, 5)); plt.show()" @@ -445,7 +222,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -461,26 +238,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "##\n", - "## Running Tigramite BivCI algorithm\n", - "##\n", - "\n", - "Parameters:\n", - "\n", - "independence test = par_corr\n", - "tau_min = 0\n", - "tau_max = 3\n" - ] - } - ], + "outputs": [], "source": [ "correlations = pcmci.run_bivci(tau_max=3, val_only=True)['val_matrix']\n", "matrix_lags = np.argmax(np.abs(correlations), axis=2)" @@ -488,5454 +248,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "##\n", - "## Optimizing pc_alpha over pc_alpha_list = [0.001, 0.005, 0.01, 0.025, 0.05]\n", - "##\n", - "\n", - "## pc_alpha = 0.001 (1/5):\n", - "\n", - "##\n", - "## Step 1: PC1 algorithm for selecting lagged conditions\n", - "##\n", - "\n", - "Parameters:\n", - "independence test = par_corr\n", - "tau_min = 1\n", - "tau_max = 3\n", - "pc_alpha = [0.001]\n", - "max_conds_dim = None\n", - "max_combinations = 1\n", - "\n", - "\n", - "\n", - "## Variable V1\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V1 (1/21):\n", - " Subset 0: () gives pval = 0.86601 / val = -0.072\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V1 (2/21):\n", - " Subset 0: () gives pval = 0.57469 / val = -0.235\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V1 (3/21):\n", - " Subset 0: () gives pval = 0.13528 / val = -0.576\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V1 (4/21):\n", - " Subset 0: () gives pval = 0.08631 / val = 0.642\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V1 (5/21):\n", - " Subset 0: () gives pval = 1.00000 / val = -0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V1 (6/21):\n", - " Subset 0: () gives pval = 0.08260 / val = -0.647\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V1 (7/21):\n", - " Subset 0: () gives pval = 0.30492 / val = -0.416\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V1 (8/21):\n", - " Subset 0: () gives pval = 0.90322 / val = -0.052\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V1 (9/21):\n", - " Subset 0: () gives pval = 0.59372 / val = 0.224\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V1 (10/21):\n", - " Subset 0: () gives pval = 0.08508 / val = -0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V1 (11/21):\n", - " Subset 0: () gives pval = 0.21081 / val = -0.496\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V1 (12/21):\n", - " Subset 0: () gives pval = 0.26642 / val = 0.447\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V1 (13/21):\n", - " Subset 0: () gives pval = 0.36475 / val = -0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V1 (14/21):\n", - " Subset 0: () gives pval = 0.97472 / val = -0.013\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V1 (15/21):\n", - " Subset 0: () gives pval = 0.28630 / val = 0.431\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V1 (16/21):\n", - " Subset 0: () gives pval = 0.69615 / val = -0.165\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V1 (17/21):\n", - " Subset 0: () gives pval = 0.60470 / val = 0.218\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V1 (18/21):\n", - " Subset 0: () gives pval = 0.64103 / val = 0.196\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V1 (19/21):\n", - " Subset 0: () gives pval = 0.32015 / val = 0.405\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V1 (20/21):\n", - " Subset 0: () gives pval = 0.67332 / val = -0.178\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V1 (21/21):\n", - " Subset 0: () gives pval = 0.52668 / val = 0.265\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V1\n", - "\n", - "## Variable V2\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V2 (1/21):\n", - " Subset 0: () gives pval = 0.12317 / val = -0.591\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V2 (2/21):\n", - " Subset 0: () gives pval = 0.87304 / val = 0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V2 (3/21):\n", - " Subset 0: () gives pval = 0.40658 / val = 0.342\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V2 (4/21):\n", - " Subset 0: () gives pval = 0.87285 / val = -0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V2 (5/21):\n", - " Subset 0: () gives pval = 0.00058 / val = -0.938\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V2 -3) -?> V2 (6/21):\n", - " Subset 0: () gives pval = 0.38647 / val = 0.356\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V2 (7/21):\n", - " Subset 0: () gives pval = 0.18843 / val = -0.518\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V2 (8/21):\n", - " Subset 0: () gives pval = 0.82124 / val = 0.096\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V2 (9/21):\n", - " Subset 0: () gives pval = 0.25844 / val = 0.454\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V2 (10/21):\n", - " Subset 0: () gives pval = 0.08165 / val = -0.649\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V2 (11/21):\n", - " Subset 0: () gives pval = 0.06607 / val = 0.675\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V2 (12/21):\n", - " Subset 0: () gives pval = 0.58825 / val = 0.227\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V2 (13/21):\n", - " Subset 0: () gives pval = 0.38186 / val = -0.359\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V2 (14/21):\n", - " Subset 0: () gives pval = 0.32916 / val = 0.398\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V2 (15/21):\n", - " Subset 0: () gives pval = 0.98847 / val = 0.006\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V2 (16/21):\n", - " Subset 0: () gives pval = 0.32076 / val = 0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V2 (17/21):\n", - " Subset 0: () gives pval = 0.40538 / val = 0.343\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V2 (18/21):\n", - " Subset 0: () gives pval = 0.37909 / val = -0.361\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V2 (19/21):\n", - " Subset 0: () gives pval = 0.96874 / val = -0.017\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V2 (20/21):\n", - " Subset 0: () gives pval = 0.29908 / val = 0.421\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V2 (21/21):\n", - " Subset 0: () gives pval = 0.32576 / val = 0.400\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", - "\n", - "Algorithm converged for variable V2\n", - "\n", - "## Variable V3\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V3 (1/21):\n", - " Subset 0: () gives pval = 0.39391 / val = -0.351\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V3 (2/21):\n", - " Subset 0: () gives pval = 0.75698 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V3 (3/21):\n", - " Subset 0: () gives pval = 0.17237 / val = 0.534\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V3 (4/21):\n", - " Subset 0: () gives pval = 0.25198 / val = 0.460\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V3 (5/21):\n", - " Subset 0: () gives pval = 0.81987 / val = -0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V3 (6/21):\n", - " Subset 0: () gives pval = 0.14919 / val = -0.560\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V3 (7/21):\n", - " Subset 0: () gives pval = 0.92814 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V3 (8/21):\n", - " Subset 0: () gives pval = 0.55198 / val = -0.249\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V3 (9/21):\n", - " Subset 0: () gives pval = 0.87647 / val = -0.066\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V3 (10/21):\n", - " Subset 0: () gives pval = 0.83660 / val = 0.088\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V3 (11/21):\n", - " Subset 0: () gives pval = 0.92891 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V3 (12/21):\n", - " Subset 0: () gives pval = 0.18176 / val = 0.525\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V3 (13/21):\n", - " Subset 0: () gives pval = 0.32210 / val = 0.403\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V3 (14/21):\n", - " Subset 0: () gives pval = 0.67508 / val = -0.177\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V3 (15/21):\n", - " Subset 0: () gives pval = 0.65106 / val = -0.191\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V3 (16/21):\n", - " Subset 0: () gives pval = 0.87265 / val = -0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V3 (17/21):\n", - " Subset 0: () gives pval = 0.73304 / val = 0.144\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V3 (18/21):\n", - " Subset 0: () gives pval = 0.71062 / val = 0.157\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V3 (19/21):\n", - " Subset 0: () gives pval = 0.08132 / val = -0.650\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V3 (20/21):\n", - " Subset 0: () gives pval = 0.65185 / val = -0.190\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V3 (21/21):\n", - " Subset 0: () gives pval = 0.71587 / val = 0.154\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V3\n", - "\n", - "## Variable V4\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V4 (1/21):\n", - " Subset 0: () gives pval = 0.56354 / val = 0.242\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V4 (2/21):\n", - " Subset 0: () gives pval = 0.58558 / val = 0.229\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V4 (3/21):\n", - " Subset 0: () gives pval = 0.96166 / val = -0.020\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V4 (4/21):\n", - " Subset 0: () gives pval = 0.16299 / val = 0.544\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V4 (5/21):\n", - " Subset 0: () gives pval = 0.24064 / val = 0.469\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V4 (6/21):\n", - " Subset 0: () gives pval = 0.06141 / val = -0.684\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V4 (7/21):\n", - " Subset 0: () gives pval = 0.94919 / val = 0.027\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V4 (8/21):\n", - " Subset 0: () gives pval = 0.02698 / val = -0.765\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V4 (9/21):\n", - " Subset 0: () gives pval = 0.35707 / val = -0.377\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V4 (10/21):\n", - " Subset 0: () gives pval = 0.77024 / val = 0.124\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V4 (11/21):\n", - " Subset 0: () gives pval = 0.12671 / val = -0.586\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V4 (12/21):\n", - " Subset 0: () gives pval = 0.87499 / val = -0.067\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V4 (13/21):\n", - " Subset 0: () gives pval = 0.45958 / val = -0.307\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V4 (14/21):\n", - " Subset 0: () gives pval = 0.72738 / val = -0.148\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V4 (15/21):\n", - " Subset 0: () gives pval = 0.29395 / val = -0.425\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V4 (16/21):\n", - " Subset 0: () gives pval = 0.88424 / val = 0.062\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V4 (17/21):\n", - " Subset 0: () gives pval = 0.17711 / val = 0.530\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V4 (18/21):\n", - " Subset 0: () gives pval = 0.81886 / val = 0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V4 (19/21):\n", - " Subset 0: () gives pval = 0.80817 / val = 0.103\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V4 (20/21):\n", - " Subset 0: () gives pval = 0.93921 / val = 0.032\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V4 (21/21):\n", - " Subset 0: () gives pval = 0.21585 / val = 0.492\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V4\n", - "\n", - "## Variable V5\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V5 (1/21):\n", - " Subset 0: () gives pval = 0.37886 / val = -0.362\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V5 (2/21):\n", - " Subset 0: () gives pval = 0.30644 / val = 0.415\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V5 (3/21):\n", - " Subset 0: () gives pval = 0.73999 / val = -0.141\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V5 (4/21):\n", - " Subset 0: () gives pval = 0.95989 / val = -0.021\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V5 (5/21):\n", - " Subset 0: () gives pval = 0.72633 / val = 0.148\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V5 (6/21):\n", - " Subset 0: () gives pval = 0.80597 / val = -0.104\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V5 (7/21):\n", - " Subset 0: () gives pval = 0.42170 / val = 0.332\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V5 (8/21):\n", - " Subset 0: () gives pval = 0.70342 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V5 (9/21):\n", - " Subset 0: () gives pval = 0.16043 / val = -0.547\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V5 (10/21):\n", - " Subset 0: () gives pval = 0.85612 / val = 0.077\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V5 (11/21):\n", - " Subset 0: () gives pval = 0.71488 / val = 0.155\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V5 (12/21):\n", - " Subset 0: () gives pval = 0.74776 / val = -0.136\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V5 (13/21):\n", - " Subset 0: () gives pval = 0.12982 / val = -0.582\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V5 (14/21):\n", - " Subset 0: () gives pval = 0.36498 / val = 0.371\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V5 (15/21):\n", - " Subset 0: () gives pval = 0.40910 / val = -0.341\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V5 (16/21):\n", - " Subset 0: () gives pval = 0.38906 / val = -0.354\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V5 (17/21):\n", - " Subset 0: () gives pval = 0.12547 / val = 0.588\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V5 (18/21):\n", - " Subset 0: () gives pval = 0.73154 / val = -0.145\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V5 (19/21):\n", - " Subset 0: () gives pval = 0.94756 / val = 0.028\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V5 (20/21):\n", - " Subset 0: () gives pval = 0.47394 / val = -0.298\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V5 (21/21):\n", - " Subset 0: () gives pval = 0.19310 / val = 0.513\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V5\n", - "\n", - "## Variable V6\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V6 (1/21):\n", - " Subset 0: () gives pval = 0.38954 / val = 0.354\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V6 (2/21):\n", - " Subset 0: () gives pval = 0.13823 / val = 0.572\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V6 (3/21):\n", - " Subset 0: () gives pval = 0.13173 / val = -0.580\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V6 (4/21):\n", - " Subset 0: () gives pval = 0.45705 / val = -0.309\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V6 (5/21):\n", - " Subset 0: () gives pval = 0.59135 / val = 0.225\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V6 (6/21):\n", - " Subset 0: () gives pval = 0.46932 / val = 0.301\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V6 (7/21):\n", - " Subset 0: () gives pval = 0.19069 / val = -0.516\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V6 (8/21):\n", - " Subset 0: () gives pval = 0.81980 / val = 0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V6 (9/21):\n", - " Subset 0: () gives pval = 0.92754 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V6 (10/21):\n", - " Subset 0: () gives pval = 0.79337 / val = -0.111\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V6 (11/21):\n", - " Subset 0: () gives pval = 0.42452 / val = -0.330\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V6 (12/21):\n", - " Subset 0: () gives pval = 0.11568 / val = -0.600\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V6 (13/21):\n", - " Subset 0: () gives pval = 0.26711 / val = -0.447\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V6 (14/21):\n", - " Subset 0: () gives pval = 0.73415 / val = -0.144\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V6 (15/21):\n", - " Subset 0: () gives pval = 0.89556 / val = 0.056\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V6 (16/21):\n", - " Subset 0: () gives pval = 0.59685 / val = 0.222\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V6 (17/21):\n", - " Subset 0: () gives pval = 0.75751 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V6 (18/21):\n", - " Subset 0: () gives pval = 0.41015 / val = -0.340\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V6 (19/21):\n", - " Subset 0: () gives pval = 0.00000 / val = 0.992\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V7 -2) -?> V6 (20/21):\n", - " Subset 0: () gives pval = 0.48406 / val = 0.291\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V6 (21/21):\n", - " Subset 0: () gives pval = 0.81090 / val = -0.102\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", - "\n", - "Algorithm converged for variable V6\n", - "\n", - "## Variable V7\n", - "\n", - "Iterating through pc_alpha = [0.001]:\n", - "\n", - "# pc_alpha = 0.001 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V7 (1/21):\n", - " Subset 0: () gives pval = 0.10602 / val = 0.613\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V7 (2/21):\n", - " Subset 0: () gives pval = 0.13143 / val = -0.580\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V7 (3/21):\n", - " Subset 0: () gives pval = 0.20399 / val = -0.503\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V7 (4/21):\n", - " Subset 0: () gives pval = 0.31711 / val = 0.407\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V7 (5/21):\n", - " Subset 0: () gives pval = 0.40496 / val = 0.343\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V7 (6/21):\n", - " Subset 0: () gives pval = 0.49089 / val = -0.287\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V7 (7/21):\n", - " Subset 0: () gives pval = 0.92032 / val = 0.043\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V7 (8/21):\n", - " Subset 0: () gives pval = 0.79775 / val = -0.109\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V7 (9/21):\n", - " Subset 0: () gives pval = 0.75377 / val = 0.133\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V7 (10/21):\n", - " Subset 0: () gives pval = 0.75703 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V7 (11/21):\n", - " Subset 0: () gives pval = 0.07150 / val = -0.666\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V7 (12/21):\n", - " Subset 0: () gives pval = 0.87683 / val = 0.066\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V7 (13/21):\n", - " Subset 0: () gives pval = 0.97094 / val = 0.016\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V7 (14/21):\n", - " Subset 0: () gives pval = 0.62396 / val = -0.206\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V7 (15/21):\n", - " Subset 0: () gives pval = 0.16865 / val = 0.538\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V7 (16/21):\n", - " Subset 0: () gives pval = 0.98554 / val = -0.008\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V7 (17/21):\n", - " Subset 0: () gives pval = 0.90824 / val = -0.049\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V7 (18/21):\n", - " Subset 0: () gives pval = 0.13870 / val = 0.572\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V7 (19/21):\n", - " Subset 0: () gives pval = 0.50733 / val = 0.277\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V7 (20/21):\n", - " Subset 0: () gives pval = 0.93834 / val = 0.033\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V7 (21/21):\n", - " Subset 0: () gives pval = 0.92994 / val = -0.037\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V7\n", - "\n", - "## Resulting lagged parent (super)sets:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "##\n", - "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", - "##\n", - "\n", - "Parameters:\n", - "\n", - "independence test = par_corr\n", - "tau_min = 0\n", - "tau_max = 3\n", - "pc_alpha = 0.001\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "reset_lagged_links = False\n", - "max_conds_dim = None\n", - "max_conds_py = None\n", - "max_conds_px = None\n", - "max_conds_px_lagged = None\n", - "fdr_method = none\n", - "\n", - "--------------------------\n", - "Skeleton discovery phase\n", - "--------------------------\n", - "\n", - "Testing contemporaneous condition sets of dimension 0: \n", - "\n", - " Link (V1 0) o?o V2 (1/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V2 -2) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.78838 / val = 0.126\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V3 (2/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.96748 / val = 0.017\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V4 (3/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.39632 / val = 0.349\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V5 (4/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.89723 / val = 0.055\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V6 (5/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.46578 / val = -0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V7 (6/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.32813 / val = 0.399\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V1 (7/44):\n", - " Already removed.\n", - "\n", - " Link (V2 -2) -?> V2 (8/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -4) ]\n", - " Subset 0: () gives pval = 0.00773 / val = -0.887\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V3 (9/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.11874 / val = -0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V4 (10/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.64856 / val = 0.212\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V5 (11/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.33073 / val = 0.434\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V6 (12/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.49710 / val = 0.349\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V7 (13/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.93791 / val = -0.037\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V1 (14/44):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V2 (15/44):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V4 (16/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.30341 / val = 0.417\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V5 (17/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.95447 / val = 0.024\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V6 (18/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.53674 / val = -0.284\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V7 (19/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.25153 / val = -0.460\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V1 (20/44):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V2 (21/44):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V3 (22/44):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V5 (23/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.20930 / val = 0.498\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V6 (24/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.26768 / val = -0.487\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V7 (25/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.92759 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V1 (26/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V2 (27/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V3 (28/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V4 (29/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V6 (30/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.38468 / val = 0.392\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V7 (31/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.32066 / val = -0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V6 0) o?o V1 (32/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V2 (33/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V3 (34/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V4 (35/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V5 (36/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V7 (37/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V7 -1) ]\n", - " Subset 0: () gives pval = 0.09642 / val = -0.675\n", - " Non-significance detected.\n", - "\n", - " Link (V7 0) o?o V1 (38/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V2 (39/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V3 (40/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V4 (41/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V5 (42/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V6 (43/44):\n", - " Already removed.\n", - "\n", - " Link (V7 -1) -?> V6 (44/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.00000 / val = 0.992\n", - " No conditions of dimension 0 left.\n", - "\n", - "Updated contemp. adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged at p = 0.\n", - "\n", - "----------------------------\n", - "Collider orientation phase\n", - "----------------------------\n", - "\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1)\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "\n", - "----------------------------\n", - "Rule orientation phase\n", - "----------------------------\n", - "\n", - "Try rule(s) [1 2 3]\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1)\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## Significant links at alpha = 0.001:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): pval = 0.00000 | val = 0.992\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## pc_alpha = 0.005 (2/5):\n", - "\n", - "##\n", - "## Step 1: PC1 algorithm for selecting lagged conditions\n", - "##\n", - "\n", - "Parameters:\n", - "independence test = par_corr\n", - "tau_min = 1\n", - "tau_max = 3\n", - "pc_alpha = [0.005]\n", - "max_conds_dim = None\n", - "max_combinations = 1\n", - "\n", - "\n", - "\n", - "## Variable V1\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V1 (1/21):\n", - " Subset 0: () gives pval = 0.86601 / val = -0.072\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V1 (2/21):\n", - " Subset 0: () gives pval = 0.57469 / val = -0.235\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V1 (3/21):\n", - " Subset 0: () gives pval = 0.13528 / val = -0.576\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V1 (4/21):\n", - " Subset 0: () gives pval = 0.08631 / val = 0.642\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V1 (5/21):\n", - " Subset 0: () gives pval = 1.00000 / val = -0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V1 (6/21):\n", - " Subset 0: () gives pval = 0.08260 / val = -0.647\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V1 (7/21):\n", - " Subset 0: () gives pval = 0.30492 / val = -0.416\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V1 (8/21):\n", - " Subset 0: () gives pval = 0.90322 / val = -0.052\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V1 (9/21):\n", - " Subset 0: () gives pval = 0.59372 / val = 0.224\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V1 (10/21):\n", - " Subset 0: () gives pval = 0.08508 / val = -0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V1 (11/21):\n", - " Subset 0: () gives pval = 0.21081 / val = -0.496\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V1 (12/21):\n", - " Subset 0: () gives pval = 0.26642 / val = 0.447\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V1 (13/21):\n", - " Subset 0: () gives pval = 0.36475 / val = -0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V1 (14/21):\n", - " Subset 0: () gives pval = 0.97472 / val = -0.013\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V1 (15/21):\n", - " Subset 0: () gives pval = 0.28630 / val = 0.431\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V1 (16/21):\n", - " Subset 0: () gives pval = 0.69615 / val = -0.165\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V1 (17/21):\n", - " Subset 0: () gives pval = 0.60470 / val = 0.218\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V1 (18/21):\n", - " Subset 0: () gives pval = 0.64103 / val = 0.196\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V1 (19/21):\n", - " Subset 0: () gives pval = 0.32015 / val = 0.405\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V1 (20/21):\n", - " Subset 0: () gives pval = 0.67332 / val = -0.178\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V1 (21/21):\n", - " Subset 0: () gives pval = 0.52668 / val = 0.265\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V1\n", - "\n", - "## Variable V2\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V2 (1/21):\n", - " Subset 0: () gives pval = 0.12317 / val = -0.591\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V2 (2/21):\n", - " Subset 0: () gives pval = 0.87304 / val = 0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V2 (3/21):\n", - " Subset 0: () gives pval = 0.40658 / val = 0.342\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V2 (4/21):\n", - " Subset 0: () gives pval = 0.87285 / val = -0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V2 (5/21):\n", - " Subset 0: () gives pval = 0.00058 / val = -0.938\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V2 -3) -?> V2 (6/21):\n", - " Subset 0: () gives pval = 0.38647 / val = 0.356\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V2 (7/21):\n", - " Subset 0: () gives pval = 0.18843 / val = -0.518\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V2 (8/21):\n", - " Subset 0: () gives pval = 0.82124 / val = 0.096\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V2 (9/21):\n", - " Subset 0: () gives pval = 0.25844 / val = 0.454\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V2 (10/21):\n", - " Subset 0: () gives pval = 0.08165 / val = -0.649\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V2 (11/21):\n", - " Subset 0: () gives pval = 0.06607 / val = 0.675\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V2 (12/21):\n", - " Subset 0: () gives pval = 0.58825 / val = 0.227\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V2 (13/21):\n", - " Subset 0: () gives pval = 0.38186 / val = -0.359\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V2 (14/21):\n", - " Subset 0: () gives pval = 0.32916 / val = 0.398\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V2 (15/21):\n", - " Subset 0: () gives pval = 0.98847 / val = 0.006\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V2 (16/21):\n", - " Subset 0: () gives pval = 0.32076 / val = 0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V2 (17/21):\n", - " Subset 0: () gives pval = 0.40538 / val = 0.343\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V2 (18/21):\n", - " Subset 0: () gives pval = 0.37909 / val = -0.361\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V2 (19/21):\n", - " Subset 0: () gives pval = 0.96874 / val = -0.017\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V2 (20/21):\n", - " Subset 0: () gives pval = 0.29908 / val = 0.421\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V2 (21/21):\n", - " Subset 0: () gives pval = 0.32576 / val = 0.400\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", - "\n", - "Algorithm converged for variable V2\n", - "\n", - "## Variable V3\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V3 (1/21):\n", - " Subset 0: () gives pval = 0.39391 / val = -0.351\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V3 (2/21):\n", - " Subset 0: () gives pval = 0.75698 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V3 (3/21):\n", - " Subset 0: () gives pval = 0.17237 / val = 0.534\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V3 (4/21):\n", - " Subset 0: () gives pval = 0.25198 / val = 0.460\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V3 (5/21):\n", - " Subset 0: () gives pval = 0.81987 / val = -0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V3 (6/21):\n", - " Subset 0: () gives pval = 0.14919 / val = -0.560\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V3 (7/21):\n", - " Subset 0: () gives pval = 0.92814 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V3 (8/21):\n", - " Subset 0: () gives pval = 0.55198 / val = -0.249\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V3 (9/21):\n", - " Subset 0: () gives pval = 0.87647 / val = -0.066\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V3 (10/21):\n", - " Subset 0: () gives pval = 0.83660 / val = 0.088\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V3 (11/21):\n", - " Subset 0: () gives pval = 0.92891 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V3 (12/21):\n", - " Subset 0: () gives pval = 0.18176 / val = 0.525\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V3 (13/21):\n", - " Subset 0: () gives pval = 0.32210 / val = 0.403\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V3 (14/21):\n", - " Subset 0: () gives pval = 0.67508 / val = -0.177\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V3 (15/21):\n", - " Subset 0: () gives pval = 0.65106 / val = -0.191\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V3 (16/21):\n", - " Subset 0: () gives pval = 0.87265 / val = -0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V3 (17/21):\n", - " Subset 0: () gives pval = 0.73304 / val = 0.144\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V3 (18/21):\n", - " Subset 0: () gives pval = 0.71062 / val = 0.157\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V3 (19/21):\n", - " Subset 0: () gives pval = 0.08132 / val = -0.650\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V3 (20/21):\n", - " Subset 0: () gives pval = 0.65185 / val = -0.190\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V3 (21/21):\n", - " Subset 0: () gives pval = 0.71587 / val = 0.154\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V3\n", - "\n", - "## Variable V4\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V4 (1/21):\n", - " Subset 0: () gives pval = 0.56354 / val = 0.242\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V4 (2/21):\n", - " Subset 0: () gives pval = 0.58558 / val = 0.229\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V4 (3/21):\n", - " Subset 0: () gives pval = 0.96166 / val = -0.020\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V4 (4/21):\n", - " Subset 0: () gives pval = 0.16299 / val = 0.544\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V4 (5/21):\n", - " Subset 0: () gives pval = 0.24064 / val = 0.469\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V4 (6/21):\n", - " Subset 0: () gives pval = 0.06141 / val = -0.684\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V4 (7/21):\n", - " Subset 0: () gives pval = 0.94919 / val = 0.027\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V4 (8/21):\n", - " Subset 0: () gives pval = 0.02698 / val = -0.765\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V4 (9/21):\n", - " Subset 0: () gives pval = 0.35707 / val = -0.377\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V4 (10/21):\n", - " Subset 0: () gives pval = 0.77024 / val = 0.124\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V4 (11/21):\n", - " Subset 0: () gives pval = 0.12671 / val = -0.586\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V4 (12/21):\n", - " Subset 0: () gives pval = 0.87499 / val = -0.067\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V4 (13/21):\n", - " Subset 0: () gives pval = 0.45958 / val = -0.307\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V4 (14/21):\n", - " Subset 0: () gives pval = 0.72738 / val = -0.148\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V4 (15/21):\n", - " Subset 0: () gives pval = 0.29395 / val = -0.425\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V4 (16/21):\n", - " Subset 0: () gives pval = 0.88424 / val = 0.062\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V4 (17/21):\n", - " Subset 0: () gives pval = 0.17711 / val = 0.530\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V4 (18/21):\n", - " Subset 0: () gives pval = 0.81886 / val = 0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V4 (19/21):\n", - " Subset 0: () gives pval = 0.80817 / val = 0.103\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V4 (20/21):\n", - " Subset 0: () gives pval = 0.93921 / val = 0.032\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V4 (21/21):\n", - " Subset 0: () gives pval = 0.21585 / val = 0.492\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V4\n", - "\n", - "## Variable V5\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V5 (1/21):\n", - " Subset 0: () gives pval = 0.37886 / val = -0.362\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V5 (2/21):\n", - " Subset 0: () gives pval = 0.30644 / val = 0.415\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V5 (3/21):\n", - " Subset 0: () gives pval = 0.73999 / val = -0.141\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V5 (4/21):\n", - " Subset 0: () gives pval = 0.95989 / val = -0.021\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V5 (5/21):\n", - " Subset 0: () gives pval = 0.72633 / val = 0.148\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V5 (6/21):\n", - " Subset 0: () gives pval = 0.80597 / val = -0.104\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V5 (7/21):\n", - " Subset 0: () gives pval = 0.42170 / val = 0.332\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V5 (8/21):\n", - " Subset 0: () gives pval = 0.70342 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V5 (9/21):\n", - " Subset 0: () gives pval = 0.16043 / val = -0.547\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V5 (10/21):\n", - " Subset 0: () gives pval = 0.85612 / val = 0.077\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V5 (11/21):\n", - " Subset 0: () gives pval = 0.71488 / val = 0.155\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V5 (12/21):\n", - " Subset 0: () gives pval = 0.74776 / val = -0.136\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V5 (13/21):\n", - " Subset 0: () gives pval = 0.12982 / val = -0.582\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V5 (14/21):\n", - " Subset 0: () gives pval = 0.36498 / val = 0.371\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V5 (15/21):\n", - " Subset 0: () gives pval = 0.40910 / val = -0.341\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V5 (16/21):\n", - " Subset 0: () gives pval = 0.38906 / val = -0.354\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V5 (17/21):\n", - " Subset 0: () gives pval = 0.12547 / val = 0.588\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V5 (18/21):\n", - " Subset 0: () gives pval = 0.73154 / val = -0.145\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V5 (19/21):\n", - " Subset 0: () gives pval = 0.94756 / val = 0.028\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V5 (20/21):\n", - " Subset 0: () gives pval = 0.47394 / val = -0.298\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V5 (21/21):\n", - " Subset 0: () gives pval = 0.19310 / val = 0.513\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V5\n", - "\n", - "## Variable V6\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V6 (1/21):\n", - " Subset 0: () gives pval = 0.38954 / val = 0.354\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V6 (2/21):\n", - " Subset 0: () gives pval = 0.13823 / val = 0.572\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V6 (3/21):\n", - " Subset 0: () gives pval = 0.13173 / val = -0.580\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V6 (4/21):\n", - " Subset 0: () gives pval = 0.45705 / val = -0.309\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V6 (5/21):\n", - " Subset 0: () gives pval = 0.59135 / val = 0.225\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V6 (6/21):\n", - " Subset 0: () gives pval = 0.46932 / val = 0.301\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V6 (7/21):\n", - " Subset 0: () gives pval = 0.19069 / val = -0.516\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V6 (8/21):\n", - " Subset 0: () gives pval = 0.81980 / val = 0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V6 (9/21):\n", - " Subset 0: () gives pval = 0.92754 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V6 (10/21):\n", - " Subset 0: () gives pval = 0.79337 / val = -0.111\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V6 (11/21):\n", - " Subset 0: () gives pval = 0.42452 / val = -0.330\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V6 (12/21):\n", - " Subset 0: () gives pval = 0.11568 / val = -0.600\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V6 (13/21):\n", - " Subset 0: () gives pval = 0.26711 / val = -0.447\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V6 (14/21):\n", - " Subset 0: () gives pval = 0.73415 / val = -0.144\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V6 (15/21):\n", - " Subset 0: () gives pval = 0.89556 / val = 0.056\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V6 (16/21):\n", - " Subset 0: () gives pval = 0.59685 / val = 0.222\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V6 (17/21):\n", - " Subset 0: () gives pval = 0.75751 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V6 (18/21):\n", - " Subset 0: () gives pval = 0.41015 / val = -0.340\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V6 (19/21):\n", - " Subset 0: () gives pval = 0.00000 / val = 0.992\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V7 -2) -?> V6 (20/21):\n", - " Subset 0: () gives pval = 0.48406 / val = 0.291\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V6 (21/21):\n", - " Subset 0: () gives pval = 0.81090 / val = -0.102\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", - "\n", - "Algorithm converged for variable V6\n", - "\n", - "## Variable V7\n", - "\n", - "Iterating through pc_alpha = [0.005]:\n", - "\n", - "# pc_alpha = 0.005 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V7 (1/21):\n", - " Subset 0: () gives pval = 0.10602 / val = 0.613\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V7 (2/21):\n", - " Subset 0: () gives pval = 0.13143 / val = -0.580\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V7 (3/21):\n", - " Subset 0: () gives pval = 0.20399 / val = -0.503\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V7 (4/21):\n", - " Subset 0: () gives pval = 0.31711 / val = 0.407\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V7 (5/21):\n", - " Subset 0: () gives pval = 0.40496 / val = 0.343\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V7 (6/21):\n", - " Subset 0: () gives pval = 0.49089 / val = -0.287\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V7 (7/21):\n", - " Subset 0: () gives pval = 0.92032 / val = 0.043\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V7 (8/21):\n", - " Subset 0: () gives pval = 0.79775 / val = -0.109\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V7 (9/21):\n", - " Subset 0: () gives pval = 0.75377 / val = 0.133\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V7 (10/21):\n", - " Subset 0: () gives pval = 0.75703 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V7 (11/21):\n", - " Subset 0: () gives pval = 0.07150 / val = -0.666\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V7 (12/21):\n", - " Subset 0: () gives pval = 0.87683 / val = 0.066\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V7 (13/21):\n", - " Subset 0: () gives pval = 0.97094 / val = 0.016\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V7 (14/21):\n", - " Subset 0: () gives pval = 0.62396 / val = -0.206\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V7 (15/21):\n", - " Subset 0: () gives pval = 0.16865 / val = 0.538\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V7 (16/21):\n", - " Subset 0: () gives pval = 0.98554 / val = -0.008\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V7 (17/21):\n", - " Subset 0: () gives pval = 0.90824 / val = -0.049\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V7 (18/21):\n", - " Subset 0: () gives pval = 0.13870 / val = 0.572\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V7 (19/21):\n", - " Subset 0: () gives pval = 0.50733 / val = 0.277\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V7 (20/21):\n", - " Subset 0: () gives pval = 0.93834 / val = 0.033\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V7 (21/21):\n", - " Subset 0: () gives pval = 0.92994 / val = -0.037\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V7\n", - "\n", - "## Resulting lagged parent (super)sets:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "##\n", - "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", - "##\n", - "\n", - "Parameters:\n", - "\n", - "independence test = par_corr\n", - "tau_min = 0\n", - "tau_max = 3\n", - "pc_alpha = 0.005\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "reset_lagged_links = False\n", - "max_conds_dim = None\n", - "max_conds_py = None\n", - "max_conds_px = None\n", - "max_conds_px_lagged = None\n", - "fdr_method = none\n", - "\n", - "--------------------------\n", - "Skeleton discovery phase\n", - "--------------------------\n", - "\n", - "Testing contemporaneous condition sets of dimension 0: \n", - "\n", - " Link (V1 0) o?o V2 (1/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V2 -2) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.78838 / val = 0.126\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V3 (2/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.96748 / val = 0.017\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V4 (3/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.39632 / val = 0.349\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V5 (4/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.89723 / val = 0.055\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V6 (5/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.46578 / val = -0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V7 (6/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.32813 / val = 0.399\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V1 (7/44):\n", - " Already removed.\n", - "\n", - " Link (V2 -2) -?> V2 (8/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -4) ]\n", - " Subset 0: () gives pval = 0.00773 / val = -0.887\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V3 (9/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.11874 / val = -0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V4 (10/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.64856 / val = 0.212\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V5 (11/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.33073 / val = 0.434\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V6 (12/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.49710 / val = 0.349\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V7 (13/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.93791 / val = -0.037\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V1 (14/44):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V2 (15/44):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V4 (16/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.30341 / val = 0.417\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V5 (17/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.95447 / val = 0.024\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V6 (18/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.53674 / val = -0.284\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V7 (19/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.25153 / val = -0.460\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V1 (20/44):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V2 (21/44):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V3 (22/44):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V5 (23/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.20930 / val = 0.498\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V6 (24/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.26768 / val = -0.487\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V7 (25/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.92759 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V1 (26/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V2 (27/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V3 (28/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V4 (29/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V6 (30/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.38468 / val = 0.392\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V7 (31/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.32066 / val = -0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V6 0) o?o V1 (32/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V2 (33/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V3 (34/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V4 (35/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V5 (36/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V7 (37/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V7 -1) ]\n", - " Subset 0: () gives pval = 0.09642 / val = -0.675\n", - " Non-significance detected.\n", - "\n", - " Link (V7 0) o?o V1 (38/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V2 (39/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V3 (40/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V4 (41/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V5 (42/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V6 (43/44):\n", - " Already removed.\n", - "\n", - " Link (V7 -1) -?> V6 (44/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.00000 / val = 0.992\n", - " No conditions of dimension 0 left.\n", - "\n", - "Updated contemp. adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged at p = 0.\n", - "\n", - "----------------------------\n", - "Collider orientation phase\n", - "----------------------------\n", - "\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1)\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "\n", - "----------------------------\n", - "Rule orientation phase\n", - "----------------------------\n", - "\n", - "Try rule(s) [1 2 3]\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1)\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## Significant links at alpha = 0.005:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): pval = 0.00000 | val = 0.992\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## pc_alpha = 0.01 (3/5):\n", - "\n", - "##\n", - "## Step 1: PC1 algorithm for selecting lagged conditions\n", - "##\n", - "\n", - "Parameters:\n", - "independence test = par_corr\n", - "tau_min = 1\n", - "tau_max = 3\n", - "pc_alpha = [0.01]\n", - "max_conds_dim = None\n", - "max_combinations = 1\n", - "\n", - "\n", - "\n", - "## Variable V1\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V1 (1/21):\n", - " Subset 0: () gives pval = 0.86601 / val = -0.072\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V1 (2/21):\n", - " Subset 0: () gives pval = 0.57469 / val = -0.235\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V1 (3/21):\n", - " Subset 0: () gives pval = 0.13528 / val = -0.576\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V1 (4/21):\n", - " Subset 0: () gives pval = 0.08631 / val = 0.642\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V1 (5/21):\n", - " Subset 0: () gives pval = 1.00000 / val = -0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V1 (6/21):\n", - " Subset 0: () gives pval = 0.08260 / val = -0.647\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V1 (7/21):\n", - " Subset 0: () gives pval = 0.30492 / val = -0.416\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V1 (8/21):\n", - " Subset 0: () gives pval = 0.90322 / val = -0.052\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V1 (9/21):\n", - " Subset 0: () gives pval = 0.59372 / val = 0.224\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V1 (10/21):\n", - " Subset 0: () gives pval = 0.08508 / val = -0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V1 (11/21):\n", - " Subset 0: () gives pval = 0.21081 / val = -0.496\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V1 (12/21):\n", - " Subset 0: () gives pval = 0.26642 / val = 0.447\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V1 (13/21):\n", - " Subset 0: () gives pval = 0.36475 / val = -0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V1 (14/21):\n", - " Subset 0: () gives pval = 0.97472 / val = -0.013\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V1 (15/21):\n", - " Subset 0: () gives pval = 0.28630 / val = 0.431\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V1 (16/21):\n", - " Subset 0: () gives pval = 0.69615 / val = -0.165\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V1 (17/21):\n", - " Subset 0: () gives pval = 0.60470 / val = 0.218\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V1 (18/21):\n", - " Subset 0: () gives pval = 0.64103 / val = 0.196\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V1 (19/21):\n", - " Subset 0: () gives pval = 0.32015 / val = 0.405\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V1 (20/21):\n", - " Subset 0: () gives pval = 0.67332 / val = -0.178\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V1 (21/21):\n", - " Subset 0: () gives pval = 0.52668 / val = 0.265\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V1\n", - "\n", - "## Variable V2\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V2 (1/21):\n", - " Subset 0: () gives pval = 0.12317 / val = -0.591\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V2 (2/21):\n", - " Subset 0: () gives pval = 0.87304 / val = 0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V2 (3/21):\n", - " Subset 0: () gives pval = 0.40658 / val = 0.342\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V2 (4/21):\n", - " Subset 0: () gives pval = 0.87285 / val = -0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V2 (5/21):\n", - " Subset 0: () gives pval = 0.00058 / val = -0.938\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V2 -3) -?> V2 (6/21):\n", - " Subset 0: () gives pval = 0.38647 / val = 0.356\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V2 (7/21):\n", - " Subset 0: () gives pval = 0.18843 / val = -0.518\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V2 (8/21):\n", - " Subset 0: () gives pval = 0.82124 / val = 0.096\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V2 (9/21):\n", - " Subset 0: () gives pval = 0.25844 / val = 0.454\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V2 (10/21):\n", - " Subset 0: () gives pval = 0.08165 / val = -0.649\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V2 (11/21):\n", - " Subset 0: () gives pval = 0.06607 / val = 0.675\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V2 (12/21):\n", - " Subset 0: () gives pval = 0.58825 / val = 0.227\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V2 (13/21):\n", - " Subset 0: () gives pval = 0.38186 / val = -0.359\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V2 (14/21):\n", - " Subset 0: () gives pval = 0.32916 / val = 0.398\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V2 (15/21):\n", - " Subset 0: () gives pval = 0.98847 / val = 0.006\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V2 (16/21):\n", - " Subset 0: () gives pval = 0.32076 / val = 0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V2 (17/21):\n", - " Subset 0: () gives pval = 0.40538 / val = 0.343\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V2 (18/21):\n", - " Subset 0: () gives pval = 0.37909 / val = -0.361\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V2 (19/21):\n", - " Subset 0: () gives pval = 0.96874 / val = -0.017\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V2 (20/21):\n", - " Subset 0: () gives pval = 0.29908 / val = 0.421\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V2 (21/21):\n", - " Subset 0: () gives pval = 0.32576 / val = 0.400\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", - "\n", - "Algorithm converged for variable V2\n", - "\n", - "## Variable V3\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V3 (1/21):\n", - " Subset 0: () gives pval = 0.39391 / val = -0.351\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V3 (2/21):\n", - " Subset 0: () gives pval = 0.75698 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V3 (3/21):\n", - " Subset 0: () gives pval = 0.17237 / val = 0.534\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V3 (4/21):\n", - " Subset 0: () gives pval = 0.25198 / val = 0.460\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V3 (5/21):\n", - " Subset 0: () gives pval = 0.81987 / val = -0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V3 (6/21):\n", - " Subset 0: () gives pval = 0.14919 / val = -0.560\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V3 (7/21):\n", - " Subset 0: () gives pval = 0.92814 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V3 (8/21):\n", - " Subset 0: () gives pval = 0.55198 / val = -0.249\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V3 (9/21):\n", - " Subset 0: () gives pval = 0.87647 / val = -0.066\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V3 (10/21):\n", - " Subset 0: () gives pval = 0.83660 / val = 0.088\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V3 (11/21):\n", - " Subset 0: () gives pval = 0.92891 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V3 (12/21):\n", - " Subset 0: () gives pval = 0.18176 / val = 0.525\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V3 (13/21):\n", - " Subset 0: () gives pval = 0.32210 / val = 0.403\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V3 (14/21):\n", - " Subset 0: () gives pval = 0.67508 / val = -0.177\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V3 (15/21):\n", - " Subset 0: () gives pval = 0.65106 / val = -0.191\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V3 (16/21):\n", - " Subset 0: () gives pval = 0.87265 / val = -0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V3 (17/21):\n", - " Subset 0: () gives pval = 0.73304 / val = 0.144\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V3 (18/21):\n", - " Subset 0: () gives pval = 0.71062 / val = 0.157\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V3 (19/21):\n", - " Subset 0: () gives pval = 0.08132 / val = -0.650\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V3 (20/21):\n", - " Subset 0: () gives pval = 0.65185 / val = -0.190\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V3 (21/21):\n", - " Subset 0: () gives pval = 0.71587 / val = 0.154\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V3\n", - "\n", - "## Variable V4\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V4 (1/21):\n", - " Subset 0: () gives pval = 0.56354 / val = 0.242\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V4 (2/21):\n", - " Subset 0: () gives pval = 0.58558 / val = 0.229\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V4 (3/21):\n", - " Subset 0: () gives pval = 0.96166 / val = -0.020\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V4 (4/21):\n", - " Subset 0: () gives pval = 0.16299 / val = 0.544\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V4 (5/21):\n", - " Subset 0: () gives pval = 0.24064 / val = 0.469\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V4 (6/21):\n", - " Subset 0: () gives pval = 0.06141 / val = -0.684\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V4 (7/21):\n", - " Subset 0: () gives pval = 0.94919 / val = 0.027\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V4 (8/21):\n", - " Subset 0: () gives pval = 0.02698 / val = -0.765\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V4 (9/21):\n", - " Subset 0: () gives pval = 0.35707 / val = -0.377\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V4 (10/21):\n", - " Subset 0: () gives pval = 0.77024 / val = 0.124\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V4 (11/21):\n", - " Subset 0: () gives pval = 0.12671 / val = -0.586\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V4 (12/21):\n", - " Subset 0: () gives pval = 0.87499 / val = -0.067\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V4 (13/21):\n", - " Subset 0: () gives pval = 0.45958 / val = -0.307\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V4 (14/21):\n", - " Subset 0: () gives pval = 0.72738 / val = -0.148\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V4 (15/21):\n", - " Subset 0: () gives pval = 0.29395 / val = -0.425\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V4 (16/21):\n", - " Subset 0: () gives pval = 0.88424 / val = 0.062\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V4 (17/21):\n", - " Subset 0: () gives pval = 0.17711 / val = 0.530\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V4 (18/21):\n", - " Subset 0: () gives pval = 0.81886 / val = 0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V4 (19/21):\n", - " Subset 0: () gives pval = 0.80817 / val = 0.103\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V4 (20/21):\n", - " Subset 0: () gives pval = 0.93921 / val = 0.032\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V4 (21/21):\n", - " Subset 0: () gives pval = 0.21585 / val = 0.492\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V4\n", - "\n", - "## Variable V5\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V5 (1/21):\n", - " Subset 0: () gives pval = 0.37886 / val = -0.362\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V5 (2/21):\n", - " Subset 0: () gives pval = 0.30644 / val = 0.415\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V5 (3/21):\n", - " Subset 0: () gives pval = 0.73999 / val = -0.141\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V5 (4/21):\n", - " Subset 0: () gives pval = 0.95989 / val = -0.021\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V5 (5/21):\n", - " Subset 0: () gives pval = 0.72633 / val = 0.148\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V5 (6/21):\n", - " Subset 0: () gives pval = 0.80597 / val = -0.104\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V5 (7/21):\n", - " Subset 0: () gives pval = 0.42170 / val = 0.332\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V5 (8/21):\n", - " Subset 0: () gives pval = 0.70342 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V5 (9/21):\n", - " Subset 0: () gives pval = 0.16043 / val = -0.547\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V5 (10/21):\n", - " Subset 0: () gives pval = 0.85612 / val = 0.077\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V5 (11/21):\n", - " Subset 0: () gives pval = 0.71488 / val = 0.155\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V5 (12/21):\n", - " Subset 0: () gives pval = 0.74776 / val = -0.136\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V5 (13/21):\n", - " Subset 0: () gives pval = 0.12982 / val = -0.582\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V5 (14/21):\n", - " Subset 0: () gives pval = 0.36498 / val = 0.371\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V5 (15/21):\n", - " Subset 0: () gives pval = 0.40910 / val = -0.341\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V5 (16/21):\n", - " Subset 0: () gives pval = 0.38906 / val = -0.354\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V5 (17/21):\n", - " Subset 0: () gives pval = 0.12547 / val = 0.588\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V5 (18/21):\n", - " Subset 0: () gives pval = 0.73154 / val = -0.145\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V5 (19/21):\n", - " Subset 0: () gives pval = 0.94756 / val = 0.028\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V5 (20/21):\n", - " Subset 0: () gives pval = 0.47394 / val = -0.298\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V5 (21/21):\n", - " Subset 0: () gives pval = 0.19310 / val = 0.513\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V5\n", - "\n", - "## Variable V6\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V6 (1/21):\n", - " Subset 0: () gives pval = 0.38954 / val = 0.354\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V6 (2/21):\n", - " Subset 0: () gives pval = 0.13823 / val = 0.572\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V6 (3/21):\n", - " Subset 0: () gives pval = 0.13173 / val = -0.580\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V6 (4/21):\n", - " Subset 0: () gives pval = 0.45705 / val = -0.309\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V6 (5/21):\n", - " Subset 0: () gives pval = 0.59135 / val = 0.225\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V6 (6/21):\n", - " Subset 0: () gives pval = 0.46932 / val = 0.301\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V6 (7/21):\n", - " Subset 0: () gives pval = 0.19069 / val = -0.516\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V6 (8/21):\n", - " Subset 0: () gives pval = 0.81980 / val = 0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V6 (9/21):\n", - " Subset 0: () gives pval = 0.92754 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V6 (10/21):\n", - " Subset 0: () gives pval = 0.79337 / val = -0.111\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V6 (11/21):\n", - " Subset 0: () gives pval = 0.42452 / val = -0.330\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V6 (12/21):\n", - " Subset 0: () gives pval = 0.11568 / val = -0.600\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V6 (13/21):\n", - " Subset 0: () gives pval = 0.26711 / val = -0.447\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V6 (14/21):\n", - " Subset 0: () gives pval = 0.73415 / val = -0.144\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V6 (15/21):\n", - " Subset 0: () gives pval = 0.89556 / val = 0.056\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V6 (16/21):\n", - " Subset 0: () gives pval = 0.59685 / val = 0.222\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V6 (17/21):\n", - " Subset 0: () gives pval = 0.75751 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V6 (18/21):\n", - " Subset 0: () gives pval = 0.41015 / val = -0.340\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V6 (19/21):\n", - " Subset 0: () gives pval = 0.00000 / val = 0.992\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V7 -2) -?> V6 (20/21):\n", - " Subset 0: () gives pval = 0.48406 / val = 0.291\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V6 (21/21):\n", - " Subset 0: () gives pval = 0.81090 / val = -0.102\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", - "\n", - "Algorithm converged for variable V6\n", - "\n", - "## Variable V7\n", - "\n", - "Iterating through pc_alpha = [0.01]:\n", - "\n", - "# pc_alpha = 0.01 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V7 (1/21):\n", - " Subset 0: () gives pval = 0.10602 / val = 0.613\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V7 (2/21):\n", - " Subset 0: () gives pval = 0.13143 / val = -0.580\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V7 (3/21):\n", - " Subset 0: () gives pval = 0.20399 / val = -0.503\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V7 (4/21):\n", - " Subset 0: () gives pval = 0.31711 / val = 0.407\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V7 (5/21):\n", - " Subset 0: () gives pval = 0.40496 / val = 0.343\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V7 (6/21):\n", - " Subset 0: () gives pval = 0.49089 / val = -0.287\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V7 (7/21):\n", - " Subset 0: () gives pval = 0.92032 / val = 0.043\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V7 (8/21):\n", - " Subset 0: () gives pval = 0.79775 / val = -0.109\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V7 (9/21):\n", - " Subset 0: () gives pval = 0.75377 / val = 0.133\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V7 (10/21):\n", - " Subset 0: () gives pval = 0.75703 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V7 (11/21):\n", - " Subset 0: () gives pval = 0.07150 / val = -0.666\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V7 (12/21):\n", - " Subset 0: () gives pval = 0.87683 / val = 0.066\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V7 (13/21):\n", - " Subset 0: () gives pval = 0.97094 / val = 0.016\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V7 (14/21):\n", - " Subset 0: () gives pval = 0.62396 / val = -0.206\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V7 (15/21):\n", - " Subset 0: () gives pval = 0.16865 / val = 0.538\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V7 (16/21):\n", - " Subset 0: () gives pval = 0.98554 / val = -0.008\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V7 (17/21):\n", - " Subset 0: () gives pval = 0.90824 / val = -0.049\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V7 (18/21):\n", - " Subset 0: () gives pval = 0.13870 / val = 0.572\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V7 (19/21):\n", - " Subset 0: () gives pval = 0.50733 / val = 0.277\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V7 (20/21):\n", - " Subset 0: () gives pval = 0.93834 / val = 0.033\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V7 (21/21):\n", - " Subset 0: () gives pval = 0.92994 / val = -0.037\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V7\n", - "\n", - "## Resulting lagged parent (super)sets:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "##\n", - "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", - "##\n", - "\n", - "Parameters:\n", - "\n", - "independence test = par_corr\n", - "tau_min = 0\n", - "tau_max = 3\n", - "pc_alpha = 0.01\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "reset_lagged_links = False\n", - "max_conds_dim = None\n", - "max_conds_py = None\n", - "max_conds_px = None\n", - "max_conds_px_lagged = None\n", - "fdr_method = none\n", - "\n", - "--------------------------\n", - "Skeleton discovery phase\n", - "--------------------------\n", - "\n", - "Testing contemporaneous condition sets of dimension 0: \n", - "\n", - " Link (V1 0) o?o V2 (1/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V2 -2) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.78838 / val = 0.126\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V3 (2/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.96748 / val = 0.017\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V4 (3/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.39632 / val = 0.349\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V5 (4/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.89723 / val = 0.055\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V6 (5/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.46578 / val = -0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V7 (6/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.32813 / val = 0.399\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V1 (7/44):\n", - " Already removed.\n", - "\n", - " Link (V2 -2) -?> V2 (8/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -4) ]\n", - " Subset 0: () gives pval = 0.00773 / val = -0.887\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V2 0) o?o V3 (9/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.11874 / val = -0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V4 (10/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.64856 / val = 0.212\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V5 (11/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.33073 / val = 0.434\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V6 (12/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.49710 / val = 0.349\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V7 (13/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.93791 / val = -0.037\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V1 (14/44):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V2 (15/44):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V4 (16/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.30341 / val = 0.417\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V5 (17/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.95447 / val = 0.024\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V6 (18/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.53674 / val = -0.284\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V7 (19/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.25153 / val = -0.460\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V1 (20/44):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V2 (21/44):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V3 (22/44):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V5 (23/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.20930 / val = 0.498\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V6 (24/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.26768 / val = -0.487\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V7 (25/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.92759 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V1 (26/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V2 (27/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V3 (28/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V4 (29/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V6 (30/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.38468 / val = 0.392\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V7 (31/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.32066 / val = -0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V6 0) o?o V1 (32/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V2 (33/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V3 (34/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V4 (35/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V5 (36/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V7 (37/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V7 -1) ]\n", - " Subset 0: () gives pval = 0.09642 / val = -0.675\n", - " Non-significance detected.\n", - "\n", - " Link (V7 0) o?o V1 (38/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V2 (39/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V3 (40/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V4 (41/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V5 (42/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V6 (43/44):\n", - " Already removed.\n", - "\n", - " Link (V7 -1) -?> V6 (44/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.00000 / val = 0.992\n", - " No conditions of dimension 0 left.\n", - "\n", - "Updated contemp. adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged at p = 0.\n", - "\n", - "----------------------------\n", - "Collider orientation phase\n", - "----------------------------\n", - "\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2)\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1)\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "\n", - "----------------------------\n", - "Rule orientation phase\n", - "----------------------------\n", - "\n", - "Try rule(s) [1 2 3]\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2)\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1)\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## Significant links at alpha = 0.01:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): pval = 0.00773 | val = -0.887\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): pval = 0.00000 | val = 0.992\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## pc_alpha = 0.025 (4/5):\n", - "\n", - "##\n", - "## Step 1: PC1 algorithm for selecting lagged conditions\n", - "##\n", - "\n", - "Parameters:\n", - "independence test = par_corr\n", - "tau_min = 1\n", - "tau_max = 3\n", - "pc_alpha = [0.025]\n", - "max_conds_dim = None\n", - "max_combinations = 1\n", - "\n", - "\n", - "\n", - "## Variable V1\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V1 (1/21):\n", - " Subset 0: () gives pval = 0.86601 / val = -0.072\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V1 (2/21):\n", - " Subset 0: () gives pval = 0.57469 / val = -0.235\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V1 (3/21):\n", - " Subset 0: () gives pval = 0.13528 / val = -0.576\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V1 (4/21):\n", - " Subset 0: () gives pval = 0.08631 / val = 0.642\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V1 (5/21):\n", - " Subset 0: () gives pval = 1.00000 / val = -0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V1 (6/21):\n", - " Subset 0: () gives pval = 0.08260 / val = -0.647\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V1 (7/21):\n", - " Subset 0: () gives pval = 0.30492 / val = -0.416\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V1 (8/21):\n", - " Subset 0: () gives pval = 0.90322 / val = -0.052\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V1 (9/21):\n", - " Subset 0: () gives pval = 0.59372 / val = 0.224\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V1 (10/21):\n", - " Subset 0: () gives pval = 0.08508 / val = -0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V1 (11/21):\n", - " Subset 0: () gives pval = 0.21081 / val = -0.496\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V1 (12/21):\n", - " Subset 0: () gives pval = 0.26642 / val = 0.447\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V1 (13/21):\n", - " Subset 0: () gives pval = 0.36475 / val = -0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V1 (14/21):\n", - " Subset 0: () gives pval = 0.97472 / val = -0.013\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V1 (15/21):\n", - " Subset 0: () gives pval = 0.28630 / val = 0.431\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V1 (16/21):\n", - " Subset 0: () gives pval = 0.69615 / val = -0.165\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V1 (17/21):\n", - " Subset 0: () gives pval = 0.60470 / val = 0.218\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V1 (18/21):\n", - " Subset 0: () gives pval = 0.64103 / val = 0.196\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V1 (19/21):\n", - " Subset 0: () gives pval = 0.32015 / val = 0.405\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V1 (20/21):\n", - " Subset 0: () gives pval = 0.67332 / val = -0.178\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V1 (21/21):\n", - " Subset 0: () gives pval = 0.52668 / val = 0.265\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V1\n", - "\n", - "## Variable V2\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V2 (1/21):\n", - " Subset 0: () gives pval = 0.12317 / val = -0.591\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V2 (2/21):\n", - " Subset 0: () gives pval = 0.87304 / val = 0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V2 (3/21):\n", - " Subset 0: () gives pval = 0.40658 / val = 0.342\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V2 (4/21):\n", - " Subset 0: () gives pval = 0.87285 / val = -0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V2 (5/21):\n", - " Subset 0: () gives pval = 0.00058 / val = -0.938\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V2 -3) -?> V2 (6/21):\n", - " Subset 0: () gives pval = 0.38647 / val = 0.356\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V2 (7/21):\n", - " Subset 0: () gives pval = 0.18843 / val = -0.518\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V2 (8/21):\n", - " Subset 0: () gives pval = 0.82124 / val = 0.096\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V2 (9/21):\n", - " Subset 0: () gives pval = 0.25844 / val = 0.454\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V2 (10/21):\n", - " Subset 0: () gives pval = 0.08165 / val = -0.649\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V2 (11/21):\n", - " Subset 0: () gives pval = 0.06607 / val = 0.675\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V2 (12/21):\n", - " Subset 0: () gives pval = 0.58825 / val = 0.227\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V2 (13/21):\n", - " Subset 0: () gives pval = 0.38186 / val = -0.359\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V2 (14/21):\n", - " Subset 0: () gives pval = 0.32916 / val = 0.398\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V2 (15/21):\n", - " Subset 0: () gives pval = 0.98847 / val = 0.006\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V2 (16/21):\n", - " Subset 0: () gives pval = 0.32076 / val = 0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V2 (17/21):\n", - " Subset 0: () gives pval = 0.40538 / val = 0.343\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V2 (18/21):\n", - " Subset 0: () gives pval = 0.37909 / val = -0.361\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V2 (19/21):\n", - " Subset 0: () gives pval = 0.96874 / val = -0.017\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V2 (20/21):\n", - " Subset 0: () gives pval = 0.29908 / val = 0.421\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V2 (21/21):\n", - " Subset 0: () gives pval = 0.32576 / val = 0.400\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", - "\n", - "Algorithm converged for variable V2\n", - "\n", - "## Variable V3\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V3 (1/21):\n", - " Subset 0: () gives pval = 0.39391 / val = -0.351\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V3 (2/21):\n", - " Subset 0: () gives pval = 0.75698 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V3 (3/21):\n", - " Subset 0: () gives pval = 0.17237 / val = 0.534\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V3 (4/21):\n", - " Subset 0: () gives pval = 0.25198 / val = 0.460\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V3 (5/21):\n", - " Subset 0: () gives pval = 0.81987 / val = -0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V3 (6/21):\n", - " Subset 0: () gives pval = 0.14919 / val = -0.560\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V3 (7/21):\n", - " Subset 0: () gives pval = 0.92814 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V3 (8/21):\n", - " Subset 0: () gives pval = 0.55198 / val = -0.249\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V3 (9/21):\n", - " Subset 0: () gives pval = 0.87647 / val = -0.066\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V3 (10/21):\n", - " Subset 0: () gives pval = 0.83660 / val = 0.088\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V3 (11/21):\n", - " Subset 0: () gives pval = 0.92891 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V3 (12/21):\n", - " Subset 0: () gives pval = 0.18176 / val = 0.525\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V3 (13/21):\n", - " Subset 0: () gives pval = 0.32210 / val = 0.403\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V3 (14/21):\n", - " Subset 0: () gives pval = 0.67508 / val = -0.177\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V3 (15/21):\n", - " Subset 0: () gives pval = 0.65106 / val = -0.191\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V3 (16/21):\n", - " Subset 0: () gives pval = 0.87265 / val = -0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V3 (17/21):\n", - " Subset 0: () gives pval = 0.73304 / val = 0.144\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V3 (18/21):\n", - " Subset 0: () gives pval = 0.71062 / val = 0.157\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V3 (19/21):\n", - " Subset 0: () gives pval = 0.08132 / val = -0.650\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V3 (20/21):\n", - " Subset 0: () gives pval = 0.65185 / val = -0.190\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V3 (21/21):\n", - " Subset 0: () gives pval = 0.71587 / val = 0.154\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V3\n", - "\n", - "## Variable V4\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V4 (1/21):\n", - " Subset 0: () gives pval = 0.56354 / val = 0.242\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V4 (2/21):\n", - " Subset 0: () gives pval = 0.58558 / val = 0.229\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V4 (3/21):\n", - " Subset 0: () gives pval = 0.96166 / val = -0.020\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V4 (4/21):\n", - " Subset 0: () gives pval = 0.16299 / val = 0.544\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V4 (5/21):\n", - " Subset 0: () gives pval = 0.24064 / val = 0.469\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V4 (6/21):\n", - " Subset 0: () gives pval = 0.06141 / val = -0.684\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V4 (7/21):\n", - " Subset 0: () gives pval = 0.94919 / val = 0.027\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V4 (8/21):\n", - " Subset 0: () gives pval = 0.02698 / val = -0.765\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V4 (9/21):\n", - " Subset 0: () gives pval = 0.35707 / val = -0.377\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V4 (10/21):\n", - " Subset 0: () gives pval = 0.77024 / val = 0.124\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V4 (11/21):\n", - " Subset 0: () gives pval = 0.12671 / val = -0.586\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V4 (12/21):\n", - " Subset 0: () gives pval = 0.87499 / val = -0.067\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V4 (13/21):\n", - " Subset 0: () gives pval = 0.45958 / val = -0.307\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V4 (14/21):\n", - " Subset 0: () gives pval = 0.72738 / val = -0.148\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V4 (15/21):\n", - " Subset 0: () gives pval = 0.29395 / val = -0.425\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V4 (16/21):\n", - " Subset 0: () gives pval = 0.88424 / val = 0.062\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V4 (17/21):\n", - " Subset 0: () gives pval = 0.17711 / val = 0.530\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V4 (18/21):\n", - " Subset 0: () gives pval = 0.81886 / val = 0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V4 (19/21):\n", - " Subset 0: () gives pval = 0.80817 / val = 0.103\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V4 (20/21):\n", - " Subset 0: () gives pval = 0.93921 / val = 0.032\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V4 (21/21):\n", - " Subset 0: () gives pval = 0.21585 / val = 0.492\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V4\n", - "\n", - "## Variable V5\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V5 (1/21):\n", - " Subset 0: () gives pval = 0.37886 / val = -0.362\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V5 (2/21):\n", - " Subset 0: () gives pval = 0.30644 / val = 0.415\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V5 (3/21):\n", - " Subset 0: () gives pval = 0.73999 / val = -0.141\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V5 (4/21):\n", - " Subset 0: () gives pval = 0.95989 / val = -0.021\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V5 (5/21):\n", - " Subset 0: () gives pval = 0.72633 / val = 0.148\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V5 (6/21):\n", - " Subset 0: () gives pval = 0.80597 / val = -0.104\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V5 (7/21):\n", - " Subset 0: () gives pval = 0.42170 / val = 0.332\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V5 (8/21):\n", - " Subset 0: () gives pval = 0.70342 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V5 (9/21):\n", - " Subset 0: () gives pval = 0.16043 / val = -0.547\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V5 (10/21):\n", - " Subset 0: () gives pval = 0.85612 / val = 0.077\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V5 (11/21):\n", - " Subset 0: () gives pval = 0.71488 / val = 0.155\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V5 (12/21):\n", - " Subset 0: () gives pval = 0.74776 / val = -0.136\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V5 (13/21):\n", - " Subset 0: () gives pval = 0.12982 / val = -0.582\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V5 (14/21):\n", - " Subset 0: () gives pval = 0.36498 / val = 0.371\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V5 (15/21):\n", - " Subset 0: () gives pval = 0.40910 / val = -0.341\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V5 (16/21):\n", - " Subset 0: () gives pval = 0.38906 / val = -0.354\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V5 (17/21):\n", - " Subset 0: () gives pval = 0.12547 / val = 0.588\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V5 (18/21):\n", - " Subset 0: () gives pval = 0.73154 / val = -0.145\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V5 (19/21):\n", - " Subset 0: () gives pval = 0.94756 / val = 0.028\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V5 (20/21):\n", - " Subset 0: () gives pval = 0.47394 / val = -0.298\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V5 (21/21):\n", - " Subset 0: () gives pval = 0.19310 / val = 0.513\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V5\n", - "\n", - "## Variable V6\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V6 (1/21):\n", - " Subset 0: () gives pval = 0.38954 / val = 0.354\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V6 (2/21):\n", - " Subset 0: () gives pval = 0.13823 / val = 0.572\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V6 (3/21):\n", - " Subset 0: () gives pval = 0.13173 / val = -0.580\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V6 (4/21):\n", - " Subset 0: () gives pval = 0.45705 / val = -0.309\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V6 (5/21):\n", - " Subset 0: () gives pval = 0.59135 / val = 0.225\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V6 (6/21):\n", - " Subset 0: () gives pval = 0.46932 / val = 0.301\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V6 (7/21):\n", - " Subset 0: () gives pval = 0.19069 / val = -0.516\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V6 (8/21):\n", - " Subset 0: () gives pval = 0.81980 / val = 0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V6 (9/21):\n", - " Subset 0: () gives pval = 0.92754 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V6 (10/21):\n", - " Subset 0: () gives pval = 0.79337 / val = -0.111\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V6 (11/21):\n", - " Subset 0: () gives pval = 0.42452 / val = -0.330\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V6 (12/21):\n", - " Subset 0: () gives pval = 0.11568 / val = -0.600\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V6 (13/21):\n", - " Subset 0: () gives pval = 0.26711 / val = -0.447\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V6 (14/21):\n", - " Subset 0: () gives pval = 0.73415 / val = -0.144\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V6 (15/21):\n", - " Subset 0: () gives pval = 0.89556 / val = 0.056\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V6 (16/21):\n", - " Subset 0: () gives pval = 0.59685 / val = 0.222\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V6 (17/21):\n", - " Subset 0: () gives pval = 0.75751 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V6 (18/21):\n", - " Subset 0: () gives pval = 0.41015 / val = -0.340\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V6 (19/21):\n", - " Subset 0: () gives pval = 0.00000 / val = 0.992\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V7 -2) -?> V6 (20/21):\n", - " Subset 0: () gives pval = 0.48406 / val = 0.291\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V6 (21/21):\n", - " Subset 0: () gives pval = 0.81090 / val = -0.102\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", - "\n", - "Algorithm converged for variable V6\n", - "\n", - "## Variable V7\n", - "\n", - "Iterating through pc_alpha = [0.025]:\n", - "\n", - "# pc_alpha = 0.025 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V7 (1/21):\n", - " Subset 0: () gives pval = 0.10602 / val = 0.613\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V7 (2/21):\n", - " Subset 0: () gives pval = 0.13143 / val = -0.580\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V7 (3/21):\n", - " Subset 0: () gives pval = 0.20399 / val = -0.503\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V7 (4/21):\n", - " Subset 0: () gives pval = 0.31711 / val = 0.407\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V7 (5/21):\n", - " Subset 0: () gives pval = 0.40496 / val = 0.343\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V7 (6/21):\n", - " Subset 0: () gives pval = 0.49089 / val = -0.287\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V7 (7/21):\n", - " Subset 0: () gives pval = 0.92032 / val = 0.043\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V7 (8/21):\n", - " Subset 0: () gives pval = 0.79775 / val = -0.109\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V7 (9/21):\n", - " Subset 0: () gives pval = 0.75377 / val = 0.133\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V7 (10/21):\n", - " Subset 0: () gives pval = 0.75703 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V7 (11/21):\n", - " Subset 0: () gives pval = 0.07150 / val = -0.666\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V7 (12/21):\n", - " Subset 0: () gives pval = 0.87683 / val = 0.066\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V7 (13/21):\n", - " Subset 0: () gives pval = 0.97094 / val = 0.016\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V7 (14/21):\n", - " Subset 0: () gives pval = 0.62396 / val = -0.206\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V7 (15/21):\n", - " Subset 0: () gives pval = 0.16865 / val = 0.538\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V7 (16/21):\n", - " Subset 0: () gives pval = 0.98554 / val = -0.008\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V7 (17/21):\n", - " Subset 0: () gives pval = 0.90824 / val = -0.049\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V7 (18/21):\n", - " Subset 0: () gives pval = 0.13870 / val = 0.572\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V7 (19/21):\n", - " Subset 0: () gives pval = 0.50733 / val = 0.277\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V7 (20/21):\n", - " Subset 0: () gives pval = 0.93834 / val = 0.033\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V7 (21/21):\n", - " Subset 0: () gives pval = 0.92994 / val = -0.037\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V7\n", - "\n", - "## Resulting lagged parent (super)sets:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "##\n", - "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", - "##\n", - "\n", - "Parameters:\n", - "\n", - "independence test = par_corr\n", - "tau_min = 0\n", - "tau_max = 3\n", - "pc_alpha = 0.025\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "reset_lagged_links = False\n", - "max_conds_dim = None\n", - "max_conds_py = None\n", - "max_conds_px = None\n", - "max_conds_px_lagged = None\n", - "fdr_method = none\n", - "\n", - "--------------------------\n", - "Skeleton discovery phase\n", - "--------------------------\n", - "\n", - "Testing contemporaneous condition sets of dimension 0: \n", - "\n", - " Link (V1 0) o?o V2 (1/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V2 -2) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.78838 / val = 0.126\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V3 (2/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.96748 / val = 0.017\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V4 (3/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.39632 / val = 0.349\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V5 (4/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.89723 / val = 0.055\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V6 (5/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.46578 / val = -0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V7 (6/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.32813 / val = 0.399\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V1 (7/44):\n", - " Already removed.\n", - "\n", - " Link (V2 -2) -?> V2 (8/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -4) ]\n", - " Subset 0: () gives pval = 0.00773 / val = -0.887\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V2 0) o?o V3 (9/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.11874 / val = -0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V4 (10/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.64856 / val = 0.212\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V5 (11/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.33073 / val = 0.434\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V6 (12/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.49710 / val = 0.349\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V7 (13/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.93791 / val = -0.037\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V1 (14/44):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V2 (15/44):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V4 (16/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.30341 / val = 0.417\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V5 (17/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.95447 / val = 0.024\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V6 (18/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.53674 / val = -0.284\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V7 (19/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.25153 / val = -0.460\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V1 (20/44):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V2 (21/44):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V3 (22/44):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V5 (23/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.20930 / val = 0.498\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V6 (24/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.26768 / val = -0.487\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V7 (25/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.92759 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V1 (26/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V2 (27/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V3 (28/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V4 (29/44):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V6 (30/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.38468 / val = 0.392\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V7 (31/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.32066 / val = -0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V6 0) o?o V1 (32/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V2 (33/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V3 (34/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V4 (35/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V5 (36/44):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V7 (37/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V7 -1) ]\n", - " Subset 0: () gives pval = 0.09642 / val = -0.675\n", - " Non-significance detected.\n", - "\n", - " Link (V7 0) o?o V1 (38/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V2 (39/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V3 (40/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V4 (41/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V5 (42/44):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V6 (43/44):\n", - " Already removed.\n", - "\n", - " Link (V7 -1) -?> V6 (44/44):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.00000 / val = 0.992\n", - " No conditions of dimension 0 left.\n", - "\n", - "Updated contemp. adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged at p = 0.\n", - "\n", - "----------------------------\n", - "Collider orientation phase\n", - "----------------------------\n", - "\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2)\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1)\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "\n", - "----------------------------\n", - "Rule orientation phase\n", - "----------------------------\n", - "\n", - "Try rule(s) [1 2 3]\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2)\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1)\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## Significant links at alpha = 0.025:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): pval = 0.00773 | val = -0.887\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): pval = 0.00000 | val = 0.992\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## pc_alpha = 0.05 (5/5):\n", - "\n", - "##\n", - "## Step 1: PC1 algorithm for selecting lagged conditions\n", - "##\n", - "\n", - "Parameters:\n", - "independence test = par_corr\n", - "tau_min = 1\n", - "tau_max = 3\n", - "pc_alpha = [0.05]\n", - "max_conds_dim = None\n", - "max_combinations = 1\n", - "\n", - "\n", - "\n", - "## Variable V1\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V1 (1/21):\n", - " Subset 0: () gives pval = 0.86601 / val = -0.072\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V1 (2/21):\n", - " Subset 0: () gives pval = 0.57469 / val = -0.235\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V1 (3/21):\n", - " Subset 0: () gives pval = 0.13528 / val = -0.576\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V1 (4/21):\n", - " Subset 0: () gives pval = 0.08631 / val = 0.642\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V1 (5/21):\n", - " Subset 0: () gives pval = 1.00000 / val = -0.000\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V1 (6/21):\n", - " Subset 0: () gives pval = 0.08260 / val = -0.647\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V1 (7/21):\n", - " Subset 0: () gives pval = 0.30492 / val = -0.416\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V1 (8/21):\n", - " Subset 0: () gives pval = 0.90322 / val = -0.052\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V1 (9/21):\n", - " Subset 0: () gives pval = 0.59372 / val = 0.224\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V1 (10/21):\n", - " Subset 0: () gives pval = 0.08508 / val = -0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V1 (11/21):\n", - " Subset 0: () gives pval = 0.21081 / val = -0.496\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V1 (12/21):\n", - " Subset 0: () gives pval = 0.26642 / val = 0.447\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V1 (13/21):\n", - " Subset 0: () gives pval = 0.36475 / val = -0.372\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V1 (14/21):\n", - " Subset 0: () gives pval = 0.97472 / val = -0.013\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V1 (15/21):\n", - " Subset 0: () gives pval = 0.28630 / val = 0.431\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V1 (16/21):\n", - " Subset 0: () gives pval = 0.69615 / val = -0.165\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V1 (17/21):\n", - " Subset 0: () gives pval = 0.60470 / val = 0.218\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V1 (18/21):\n", - " Subset 0: () gives pval = 0.64103 / val = 0.196\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V1 (19/21):\n", - " Subset 0: () gives pval = 0.32015 / val = 0.405\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V1 (20/21):\n", - " Subset 0: () gives pval = 0.67332 / val = -0.178\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V1 (21/21):\n", - " Subset 0: () gives pval = 0.52668 / val = 0.265\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V1\n", - "\n", - "## Variable V2\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V2 (1/21):\n", - " Subset 0: () gives pval = 0.12317 / val = -0.591\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V2 (2/21):\n", - " Subset 0: () gives pval = 0.87304 / val = 0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V2 (3/21):\n", - " Subset 0: () gives pval = 0.40658 / val = 0.342\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V2 (4/21):\n", - " Subset 0: () gives pval = 0.87285 / val = -0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V2 (5/21):\n", - " Subset 0: () gives pval = 0.00058 / val = -0.938\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V2 -3) -?> V2 (6/21):\n", - " Subset 0: () gives pval = 0.38647 / val = 0.356\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V2 (7/21):\n", - " Subset 0: () gives pval = 0.18843 / val = -0.518\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V2 (8/21):\n", - " Subset 0: () gives pval = 0.82124 / val = 0.096\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V2 (9/21):\n", - " Subset 0: () gives pval = 0.25844 / val = 0.454\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V2 (10/21):\n", - " Subset 0: () gives pval = 0.08165 / val = -0.649\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V2 (11/21):\n", - " Subset 0: () gives pval = 0.06607 / val = 0.675\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V2 (12/21):\n", - " Subset 0: () gives pval = 0.58825 / val = 0.227\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V2 (13/21):\n", - " Subset 0: () gives pval = 0.38186 / val = -0.359\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V2 (14/21):\n", - " Subset 0: () gives pval = 0.32916 / val = 0.398\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V2 (15/21):\n", - " Subset 0: () gives pval = 0.98847 / val = 0.006\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V2 (16/21):\n", - " Subset 0: () gives pval = 0.32076 / val = 0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V2 (17/21):\n", - " Subset 0: () gives pval = 0.40538 / val = 0.343\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V2 (18/21):\n", - " Subset 0: () gives pval = 0.37909 / val = -0.361\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V2 (19/21):\n", - " Subset 0: () gives pval = 0.96874 / val = -0.017\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V2 (20/21):\n", - " Subset 0: () gives pval = 0.29908 / val = 0.421\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V2 (21/21):\n", - " Subset 0: () gives pval = 0.32576 / val = 0.400\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", - "\n", - "Algorithm converged for variable V2\n", - "\n", - "## Variable V3\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V3 (1/21):\n", - " Subset 0: () gives pval = 0.39391 / val = -0.351\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V3 (2/21):\n", - " Subset 0: () gives pval = 0.75698 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V3 (3/21):\n", - " Subset 0: () gives pval = 0.17237 / val = 0.534\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V3 (4/21):\n", - " Subset 0: () gives pval = 0.25198 / val = 0.460\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V3 (5/21):\n", - " Subset 0: () gives pval = 0.81987 / val = -0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V3 (6/21):\n", - " Subset 0: () gives pval = 0.14919 / val = -0.560\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V3 (7/21):\n", - " Subset 0: () gives pval = 0.92814 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V3 (8/21):\n", - " Subset 0: () gives pval = 0.55198 / val = -0.249\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V3 (9/21):\n", - " Subset 0: () gives pval = 0.87647 / val = -0.066\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V3 (10/21):\n", - " Subset 0: () gives pval = 0.83660 / val = 0.088\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V3 (11/21):\n", - " Subset 0: () gives pval = 0.92891 / val = 0.038\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V3 (12/21):\n", - " Subset 0: () gives pval = 0.18176 / val = 0.525\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V3 (13/21):\n", - " Subset 0: () gives pval = 0.32210 / val = 0.403\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V3 (14/21):\n", - " Subset 0: () gives pval = 0.67508 / val = -0.177\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V3 (15/21):\n", - " Subset 0: () gives pval = 0.65106 / val = -0.191\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V3 (16/21):\n", - " Subset 0: () gives pval = 0.87265 / val = -0.068\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V3 (17/21):\n", - " Subset 0: () gives pval = 0.73304 / val = 0.144\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V3 (18/21):\n", - " Subset 0: () gives pval = 0.71062 / val = 0.157\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V3 (19/21):\n", - " Subset 0: () gives pval = 0.08132 / val = -0.650\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V3 (20/21):\n", - " Subset 0: () gives pval = 0.65185 / val = -0.190\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V3 (21/21):\n", - " Subset 0: () gives pval = 0.71587 / val = 0.154\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V3\n", - "\n", - "## Variable V4\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V4 (1/21):\n", - " Subset 0: () gives pval = 0.56354 / val = 0.242\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V4 (2/21):\n", - " Subset 0: () gives pval = 0.58558 / val = 0.229\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V4 (3/21):\n", - " Subset 0: () gives pval = 0.96166 / val = -0.020\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V4 (4/21):\n", - " Subset 0: () gives pval = 0.16299 / val = 0.544\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V4 (5/21):\n", - " Subset 0: () gives pval = 0.24064 / val = 0.469\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V4 (6/21):\n", - " Subset 0: () gives pval = 0.06141 / val = -0.684\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V4 (7/21):\n", - " Subset 0: () gives pval = 0.94919 / val = 0.027\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V4 (8/21):\n", - " Subset 0: () gives pval = 0.02698 / val = -0.765\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V3 -3) -?> V4 (9/21):\n", - " Subset 0: () gives pval = 0.35707 / val = -0.377\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V4 (10/21):\n", - " Subset 0: () gives pval = 0.77024 / val = 0.124\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V4 (11/21):\n", - " Subset 0: () gives pval = 0.12671 / val = -0.586\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V4 (12/21):\n", - " Subset 0: () gives pval = 0.87499 / val = -0.067\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V4 (13/21):\n", - " Subset 0: () gives pval = 0.45958 / val = -0.307\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V4 (14/21):\n", - " Subset 0: () gives pval = 0.72738 / val = -0.148\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V4 (15/21):\n", - " Subset 0: () gives pval = 0.29395 / val = -0.425\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V4 (16/21):\n", - " Subset 0: () gives pval = 0.88424 / val = 0.062\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V4 (17/21):\n", - " Subset 0: () gives pval = 0.17711 / val = 0.530\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V4 (18/21):\n", - " Subset 0: () gives pval = 0.81886 / val = 0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V4 (19/21):\n", - " Subset 0: () gives pval = 0.80817 / val = 0.103\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V4 (20/21):\n", - " Subset 0: () gives pval = 0.93921 / val = 0.032\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V4 (21/21):\n", - " Subset 0: () gives pval = 0.21585 / val = 0.492\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V4 has 1 link(s):\n", - " (V3 -2): max_pval = 0.02698, |min_val| = 0.765\n", - "\n", - "Algorithm converged for variable V4\n", - "\n", - "## Variable V5\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V5 (1/21):\n", - " Subset 0: () gives pval = 0.37886 / val = -0.362\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V5 (2/21):\n", - " Subset 0: () gives pval = 0.30644 / val = 0.415\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V5 (3/21):\n", - " Subset 0: () gives pval = 0.73999 / val = -0.141\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V5 (4/21):\n", - " Subset 0: () gives pval = 0.95989 / val = -0.021\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V5 (5/21):\n", - " Subset 0: () gives pval = 0.72633 / val = 0.148\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V5 (6/21):\n", - " Subset 0: () gives pval = 0.80597 / val = -0.104\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V5 (7/21):\n", - " Subset 0: () gives pval = 0.42170 / val = 0.332\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V5 (8/21):\n", - " Subset 0: () gives pval = 0.70342 / val = -0.161\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V5 (9/21):\n", - " Subset 0: () gives pval = 0.16043 / val = -0.547\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V5 (10/21):\n", - " Subset 0: () gives pval = 0.85612 / val = 0.077\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V5 (11/21):\n", - " Subset 0: () gives pval = 0.71488 / val = 0.155\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V5 (12/21):\n", - " Subset 0: () gives pval = 0.74776 / val = -0.136\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V5 (13/21):\n", - " Subset 0: () gives pval = 0.12982 / val = -0.582\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V5 (14/21):\n", - " Subset 0: () gives pval = 0.36498 / val = 0.371\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V5 (15/21):\n", - " Subset 0: () gives pval = 0.40910 / val = -0.341\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V5 (16/21):\n", - " Subset 0: () gives pval = 0.38906 / val = -0.354\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V5 (17/21):\n", - " Subset 0: () gives pval = 0.12547 / val = 0.588\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V5 (18/21):\n", - " Subset 0: () gives pval = 0.73154 / val = -0.145\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V5 (19/21):\n", - " Subset 0: () gives pval = 0.94756 / val = 0.028\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V5 (20/21):\n", - " Subset 0: () gives pval = 0.47394 / val = -0.298\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V5 (21/21):\n", - " Subset 0: () gives pval = 0.19310 / val = 0.513\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V5\n", - "\n", - "## Variable V6\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V6 (1/21):\n", - " Subset 0: () gives pval = 0.38954 / val = 0.354\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V6 (2/21):\n", - " Subset 0: () gives pval = 0.13823 / val = 0.572\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V6 (3/21):\n", - " Subset 0: () gives pval = 0.13173 / val = -0.580\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V6 (4/21):\n", - " Subset 0: () gives pval = 0.45705 / val = -0.309\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V6 (5/21):\n", - " Subset 0: () gives pval = 0.59135 / val = 0.225\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V6 (6/21):\n", - " Subset 0: () gives pval = 0.46932 / val = 0.301\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V6 (7/21):\n", - " Subset 0: () gives pval = 0.19069 / val = -0.516\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V6 (8/21):\n", - " Subset 0: () gives pval = 0.81980 / val = 0.097\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V6 (9/21):\n", - " Subset 0: () gives pval = 0.92754 / val = -0.039\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V6 (10/21):\n", - " Subset 0: () gives pval = 0.79337 / val = -0.111\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V6 (11/21):\n", - " Subset 0: () gives pval = 0.42452 / val = -0.330\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V6 (12/21):\n", - " Subset 0: () gives pval = 0.11568 / val = -0.600\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V6 (13/21):\n", - " Subset 0: () gives pval = 0.26711 / val = -0.447\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V6 (14/21):\n", - " Subset 0: () gives pval = 0.73415 / val = -0.144\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V6 (15/21):\n", - " Subset 0: () gives pval = 0.89556 / val = 0.056\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V6 (16/21):\n", - " Subset 0: () gives pval = 0.59685 / val = 0.222\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V6 (17/21):\n", - " Subset 0: () gives pval = 0.75751 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V6 (18/21):\n", - " Subset 0: () gives pval = 0.41015 / val = -0.340\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V6 (19/21):\n", - " Subset 0: () gives pval = 0.00000 / val = 0.992\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V7 -2) -?> V6 (20/21):\n", - " Subset 0: () gives pval = 0.48406 / val = 0.291\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V6 (21/21):\n", - " Subset 0: () gives pval = 0.81090 / val = -0.102\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", - "\n", - "Algorithm converged for variable V6\n", - "\n", - "## Variable V7\n", - "\n", - "Iterating through pc_alpha = [0.05]:\n", - "\n", - "# pc_alpha = 0.05 (1/1):\n", - "\n", - "Testing condition sets of dimension 0:\n", - "\n", - " Link (V1 -1) -?> V7 (1/21):\n", - " Subset 0: () gives pval = 0.10602 / val = 0.613\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -2) -?> V7 (2/21):\n", - " Subset 0: () gives pval = 0.13143 / val = -0.580\n", - " Non-significance detected.\n", - "\n", - " Link (V1 -3) -?> V7 (3/21):\n", - " Subset 0: () gives pval = 0.20399 / val = -0.503\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -1) -?> V7 (4/21):\n", - " Subset 0: () gives pval = 0.31711 / val = 0.407\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -2) -?> V7 (5/21):\n", - " Subset 0: () gives pval = 0.40496 / val = 0.343\n", - " Non-significance detected.\n", - "\n", - " Link (V2 -3) -?> V7 (6/21):\n", - " Subset 0: () gives pval = 0.49089 / val = -0.287\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -1) -?> V7 (7/21):\n", - " Subset 0: () gives pval = 0.92032 / val = 0.043\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V7 (8/21):\n", - " Subset 0: () gives pval = 0.79775 / val = -0.109\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -3) -?> V7 (9/21):\n", - " Subset 0: () gives pval = 0.75377 / val = 0.133\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -1) -?> V7 (10/21):\n", - " Subset 0: () gives pval = 0.75703 / val = -0.131\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -2) -?> V7 (11/21):\n", - " Subset 0: () gives pval = 0.07150 / val = -0.666\n", - " Non-significance detected.\n", - "\n", - " Link (V4 -3) -?> V7 (12/21):\n", - " Subset 0: () gives pval = 0.87683 / val = 0.066\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -1) -?> V7 (13/21):\n", - " Subset 0: () gives pval = 0.97094 / val = 0.016\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -2) -?> V7 (14/21):\n", - " Subset 0: () gives pval = 0.62396 / val = -0.206\n", - " Non-significance detected.\n", - "\n", - " Link (V5 -3) -?> V7 (15/21):\n", - " Subset 0: () gives pval = 0.16865 / val = 0.538\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -1) -?> V7 (16/21):\n", - " Subset 0: () gives pval = 0.98554 / val = -0.008\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -2) -?> V7 (17/21):\n", - " Subset 0: () gives pval = 0.90824 / val = -0.049\n", - " Non-significance detected.\n", - "\n", - " Link (V6 -3) -?> V7 (18/21):\n", - " Subset 0: () gives pval = 0.13870 / val = 0.572\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -1) -?> V7 (19/21):\n", - " Subset 0: () gives pval = 0.50733 / val = 0.277\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -2) -?> V7 (20/21):\n", - " Subset 0: () gives pval = 0.93834 / val = 0.033\n", - " Non-significance detected.\n", - "\n", - " Link (V7 -3) -?> V7 (21/21):\n", - " Subset 0: () gives pval = 0.92994 / val = -0.037\n", - " Non-significance detected.\n", - "\n", - " Sorting parents in decreasing order with \n", - " weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| \n", - "\n", - "Updating parents:\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged for variable V7\n", - "\n", - "## Resulting lagged parent (super)sets:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): max_pval = 0.00058, |min_val| = 0.938\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 1 link(s):\n", - " (V3 -2): max_pval = 0.02698, |min_val| = 0.765\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): max_pval = 0.00000, |min_val| = 0.992\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "##\n", - "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", - "##\n", - "\n", - "Parameters:\n", - "\n", - "independence test = par_corr\n", - "tau_min = 0\n", - "tau_max = 3\n", - "pc_alpha = 0.05\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "reset_lagged_links = False\n", - "max_conds_dim = None\n", - "max_conds_py = None\n", - "max_conds_px = None\n", - "max_conds_px_lagged = None\n", - "fdr_method = none\n", - "\n", - "--------------------------\n", - "Skeleton discovery phase\n", - "--------------------------\n", - "\n", - "Testing contemporaneous condition sets of dimension 0: \n", - "\n", - " Link (V1 0) o?o V2 (1/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V2 -2) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.78838 / val = 0.126\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V3 (2/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.96748 / val = 0.017\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V4 (3/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V3 -2) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.27373 / val = 0.482\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V5 (4/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.89723 / val = 0.055\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V6 (5/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.46578 / val = -0.333\n", - " Non-significance detected.\n", - "\n", - " Link (V1 0) o?o V7 (6/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.32813 / val = 0.399\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V1 (7/45):\n", - " Already removed.\n", - "\n", - " Link (V2 -2) -?> V2 (8/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -4) ]\n", - " Subset 0: () gives pval = 0.00773 / val = -0.887\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V2 0) o?o V3 (9/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.11874 / val = -0.644\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V4 (10/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V3 -2) ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.95232 / val = 0.032\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V5 (11/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.33073 / val = 0.434\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V6 (12/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.49710 / val = 0.349\n", - " Non-significance detected.\n", - "\n", - " Link (V2 0) o?o V7 (13/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V2 -2) ]\n", - " Subset 0: () gives pval = 0.93791 / val = -0.037\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V1 (14/45):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V2 (15/45):\n", - " Already removed.\n", - "\n", - " Link (V3 0) o?o V4 (16/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V3 -2) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.42232 / val = 0.364\n", - " Non-significance detected.\n", - "\n", - " Link (V3 -2) -?> V4 (17/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.02698 / val = -0.765\n", - " No conditions of dimension 0 left.\n", - "\n", - " Link (V3 0) o?o V5 (18/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.95447 / val = 0.024\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V6 (19/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.53674 / val = -0.284\n", - " Non-significance detected.\n", - "\n", - " Link (V3 0) o?o V7 (20/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.25153 / val = -0.460\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V1 (21/45):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V2 (22/45):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V3 (23/45):\n", - " Already removed.\n", - "\n", - " Link (V4 0) o?o V5 (24/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V3 -2) ]\n", - " Subset 0: () gives pval = 0.16356 / val = 0.590\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V6 (25/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ (V3 -2) ]\n", - " Subset 0: () gives pval = 0.84717 / val = -0.102\n", - " Non-significance detected.\n", - "\n", - " Link (V4 0) o?o V7 (26/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V3 -2) ]\n", - " Subset 0: () gives pval = 0.68274 / val = -0.190\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V1 (27/45):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V2 (28/45):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V3 (29/45):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V4 (30/45):\n", - " Already removed.\n", - "\n", - " Link (V5 0) o?o V6 (31/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ (V7 -1) ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.38468 / val = 0.392\n", - " Non-significance detected.\n", - "\n", - " Link (V5 0) o?o V7 (32/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.32066 / val = -0.404\n", - " Non-significance detected.\n", - "\n", - " Link (V6 0) o?o V1 (33/45):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V2 (34/45):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V3 (35/45):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V4 (36/45):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V5 (37/45):\n", - " Already removed.\n", - "\n", - " Link (V6 0) o?o V7 (38/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ (V7 -1) ]\n", - " Subset 0: () gives pval = 0.09642 / val = -0.675\n", - " Non-significance detected.\n", - "\n", - " Link (V7 0) o?o V1 (39/45):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V2 (40/45):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V3 (41/45):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V4 (42/45):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V5 (43/45):\n", - " Already removed.\n", - "\n", - " Link (V7 0) o?o V6 (44/45):\n", - " Already removed.\n", - "\n", - " Link (V7 -1) -?> V6 (45/45):\n", - " Iterate through 1 subset(s) of conditions: \n", - " with conds_y = [ ]\n", - " with conds_x = [ ]\n", - " Subset 0: () gives pval = 0.00000 / val = 0.992\n", - " No conditions of dimension 0 left.\n", - "\n", - "Updated contemp. adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 0 link(s):\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 0 link(s):\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 0 link(s):\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "Algorithm converged at p = 0.\n", - "\n", - "----------------------------\n", - "Collider orientation phase\n", - "----------------------------\n", - "\n", - "contemp_collider_rule = majority\n", - "conflict_resolution = True\n", - "\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2)\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 1 link(s):\n", - " (V3 -2)\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1)\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "\n", - "----------------------------\n", - "Rule orientation phase\n", - "----------------------------\n", - "\n", - "Try rule(s) [1 2 3]\n", - "\n", - "Updated adjacencies:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2)\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 1 link(s):\n", - " (V3 -2)\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1)\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "## Significant links at alpha = 0.05:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): pval = 0.00773 | val = -0.887\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 1 link(s):\n", - " (V3 -2): pval = 0.02698 | val = -0.765\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): pval = 0.00000 | val = 0.992\n", - "\n", - " Variable V7 has 0 link(s):\n", - "\n", - "##\n", - "\n", - "## Scores for individual pc_alpha values:\n", - "\n", - " pc_alpha = 0.001 yields score = 14.18332\n", - " pc_alpha = 0.005 yields score = 14.18332\n", - " pc_alpha = 0.01 yields score = 12.05241\n", - " pc_alpha = 0.025 yields score = 12.05241\n", - " pc_alpha = 0.05 yields score = 11.33224\n", - "\n", - "##\n", - "## Results for optimal pc_alpha = 0.05\n", - "##\n", - "\n", - "## Significant links at alpha = 0.05:\n", - "\n", - " Variable V1 has 0 link(s):\n", - "\n", - " Variable V2 has 1 link(s):\n", - " (V2 -2): pval = 0.00773 | val = -0.887\n", - "\n", - " Variable V3 has 0 link(s):\n", - "\n", - " Variable V4 has 1 link(s):\n", - " (V3 -2): pval = 0.02698 | val = -0.765\n", - "\n", - " Variable V5 has 0 link(s):\n", - "\n", - " Variable V6 has 1 link(s):\n", - " (V7 -1): pval = 0.00000 | val = 0.992\n", - "\n", - " Variable V7 has 0 link(s):\n" - ] - } - ], + "outputs": [], "source": [ "tau_max = 3\n", "pc_alpha = None\n", @@ -5946,20 +261,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from dowhy.utils.timeseries import create_graph_from_networkx_array\n", "\n", From cd54fabeca7baee64be5d6c4ccf19c6515bb762a Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 2 Aug 2024 09:16:51 +0000 Subject: [PATCH 64/67] updated tests for lagged shift --- tests/timeseries/test_temporal_shift.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/tests/timeseries/test_temporal_shift.py b/tests/timeseries/test_temporal_shift.py index 1fc42c3a6..6b0a4638e 100644 --- a/tests/timeseries/test_temporal_shift.py +++ b/tests/timeseries/test_temporal_shift.py @@ -36,11 +36,18 @@ def test_multiple_time_lags(self): self.assertTrue(new_graph.has_node("B_-1")) self.assertTrue(new_graph.has_node("B_-3")) self.assertTrue(new_graph.has_node("A_-2")) + self.assertTrue(new_graph.has_node("A_-3")) self.assertTrue(new_graph.has_node("A_-4")) + self.assertTrue(new_graph.has_node("A_-5")) self.assertTrue(new_graph.has_edge("B_-1", "C_0")) self.assertTrue(new_graph.has_edge("B_-3", "C_0")) self.assertTrue(new_graph.has_edge("A_-2", "B_-1")) self.assertTrue(new_graph.has_edge("A_-4", "B_-3")) + self.assertTrue(new_graph.has_edge("B_-3", "B_-1")) + self.assertTrue(new_graph.has_edge("A_-5", "A_-4")) + self.assertTrue(new_graph.has_edge("A_-4", "A_-3")) + self.assertTrue(new_graph.has_edge("A_-3", "A_-2")) + def test_complex_graph_structure(self): graph = nx.DiGraph() @@ -56,7 +63,6 @@ def test_complex_graph_structure(self): self.assertTrue(new_graph.has_node("A_-3")) self.assertTrue(new_graph.has_edge("B_-2", "C_0")) self.assertTrue(new_graph.has_edge("A_-3", "B_-2")) - self.assertTrue(new_graph.has_node("A_-3")) self.assertTrue(new_graph.has_edge("A_-3", "C_0")) def test_no_time_lag(self): From 5c75284e6c1238181bf90ddd395bcff9b70fcdc7 Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 2 Aug 2024 11:12:30 +0000 Subject: [PATCH 65/67] formatting for tests --- tests/timeseries/test_temporal_shift.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/timeseries/test_temporal_shift.py b/tests/timeseries/test_temporal_shift.py index 6b0a4638e..b663609b4 100644 --- a/tests/timeseries/test_temporal_shift.py +++ b/tests/timeseries/test_temporal_shift.py @@ -48,7 +48,6 @@ def test_multiple_time_lags(self): self.assertTrue(new_graph.has_edge("A_-4", "A_-3")) self.assertTrue(new_graph.has_edge("A_-3", "A_-2")) - def test_complex_graph_structure(self): graph = nx.DiGraph() graph.add_edge("A", "B", time_lag=(1,)) From c94357aa2736409e850e9320b90d565ba44cf31d Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 2 Aug 2024 11:14:07 +0000 Subject: [PATCH 66/67] formatting --- dowhy/timeseries/temporal_shift.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dowhy/timeseries/temporal_shift.py b/dowhy/timeseries/temporal_shift.py index 58c2e0b19..82c933cdf 100644 --- a/dowhy/timeseries/temporal_shift.py +++ b/dowhy/timeseries/temporal_shift.py @@ -66,7 +66,7 @@ def add_lagged_edges(graph: nx.DiGraph, start_node: str) -> nx.DiGraph: lagged_node_mapping[parent] = new_lagged_nodes for original_node, lagged_nodes in lagged_node_mapping.items(): - sorted_lagged_nodes = sorted(lagged_nodes, key=lambda x: int(x.split('_')[-1])) + sorted_lagged_nodes = sorted(lagged_nodes, key=lambda x: int(x.split("_")[-1])) for i in range(len(sorted_lagged_nodes) - 1): lesser_lagged_node = sorted_lagged_nodes[i] more_lagged_node = sorted_lagged_nodes[i + 1] From 81f1b3474936470bca9b33423b350bbb6f940e2e Mon Sep 17 00:00:00 2001 From: Ashutosh Srivastava Date: Fri, 2 Aug 2024 13:49:35 +0000 Subject: [PATCH 67/67] tigramite dependency added --- .../timeseries/effect_inference_timeseries_data.ipynb | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb index 8f2eb41d6..1d77bef6b 100644 --- a/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb +++ b/docs/source/example_notebooks/timeseries/effect_inference_timeseries_data.ipynb @@ -193,6 +193,15 @@ "Tigramite is a popular temporal causal discovery library. In this section, we highlight how the causal graph can be obtained by applying PCMCI+ algorithm from tigramite and imported into DoWhy." ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install tigramite" + ] + }, { "cell_type": "code", "execution_count": null,