GLDF 0.9.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- GLDF/__init__.py +2 -0
- GLDF/bridges/__init__.py +0 -0
- GLDF/bridges/causal_learn.py +185 -0
- GLDF/bridges/tigramite.py +143 -0
- GLDF/bridges/tigramite_plotting_modified.py +4764 -0
- GLDF/cit.py +274 -0
- GLDF/data_management.py +588 -0
- GLDF/data_processing.py +754 -0
- GLDF/frontend.py +537 -0
- GLDF/hccd.py +403 -0
- GLDF/hyperparams.py +205 -0
- GLDF/independence_atoms.py +78 -0
- GLDF/state_space_construction.py +288 -0
- GLDF/tutorials/01_preconfigured_quickstart.ipynb +302 -0
- GLDF/tutorials/02_detailed_configuration.ipynb +394 -0
- GLDF/tutorials/03_custom_patterns.ipynb +447 -0
- gldf-0.9.0.dist-info/METADATA +101 -0
- gldf-0.9.0.dist-info/RECORD +20 -0
- gldf-0.9.0.dist-info/WHEEL +4 -0
- gldf-0.9.0.dist-info/licenses/LICENSE +621 -0
|
@@ -0,0 +1,394 @@
|
|
|
1
|
+
{
|
|
2
|
+
"cells": [
|
|
3
|
+
{
|
|
4
|
+
"cell_type": "code",
|
|
5
|
+
"execution_count": 1,
|
|
6
|
+
"id": "955d4f40",
|
|
7
|
+
"metadata": {},
|
|
8
|
+
"outputs": [],
|
|
9
|
+
"source": [
|
|
10
|
+
"import GLDF"
|
|
11
|
+
]
|
|
12
|
+
},
|
|
13
|
+
{
|
|
14
|
+
"cell_type": "markdown",
|
|
15
|
+
"id": "33f5fb3e",
|
|
16
|
+
"metadata": {},
|
|
17
|
+
"source": [
|
|
18
|
+
"# Tutorial 02: More Detailed Configurations\n",
|
|
19
|
+
"\n",
|
|
20
|
+
"This tutorial presents again two simple examples (similar to those in the first tutorial):\n",
|
|
21
|
+
"1. Application to time series data with temporally persistent regimes, this time configured for latents\n",
|
|
22
|
+
"2. Application to gridded data with spatially localized regimes, this time using PC-stable in place of FCI"
|
|
23
|
+
]
|
|
24
|
+
},
|
|
25
|
+
{
|
|
26
|
+
"cell_type": "markdown",
|
|
27
|
+
"id": "b32274c9",
|
|
28
|
+
"metadata": {},
|
|
29
|
+
"source": [
|
|
30
|
+
"## 1. Time-Series and Latents\n",
|
|
31
|
+
"\n",
|
|
32
|
+
"Time-series with latents by using tigramite's LPCMCI implementation works out of the box, using 'run_hccd_temporal_regimes' with 'allow_latent_confounding=True' option.\n",
|
|
33
|
+
"This part of the tutorial explains, how the built-in configurations can be customized, on the example of reimplementing this feature.\n",
|
|
34
|
+
"\n",
|
|
35
|
+
"The standard-configurations are data-classes, and we can inspect parameters as follows\n",
|
|
36
|
+
"(these simple parameters can be modified simply by obtaining a configuration object, e.g. via configure_hccd_temporal_regimes, overwriting the value, and then calling run(data)\n",
|
|
37
|
+
"on the configuration object):"
|
|
38
|
+
]
|
|
39
|
+
},
|
|
40
|
+
{
|
|
41
|
+
"cell_type": "code",
|
|
42
|
+
"execution_count": 2,
|
|
43
|
+
"id": "e09a004f",
|
|
44
|
+
"metadata": {},
|
|
45
|
+
"outputs": [
|
|
46
|
+
{
|
|
47
|
+
"name": "stdout",
|
|
48
|
+
"output_type": "stream",
|
|
49
|
+
"text": [
|
|
50
|
+
"{'is_timeseries': True, 'alpha': 0.01, 'min_regime_fraction': 0.15, 'indicator_resolution_granularity': 100, 'regimes_are_large': True, 'tau_max': 1, 'alpha_pc1': 0.1, '_data': None}\n"
|
|
51
|
+
]
|
|
52
|
+
}
|
|
53
|
+
],
|
|
54
|
+
"source": [
|
|
55
|
+
"\n",
|
|
56
|
+
"from dataclasses import asdict\n",
|
|
57
|
+
"print(asdict(GLDF.frontend.configure_hccd_temporal_regimes()))"
|
|
58
|
+
]
|
|
59
|
+
},
|
|
60
|
+
{
|
|
61
|
+
"cell_type": "markdown",
|
|
62
|
+
"id": "208b3652",
|
|
63
|
+
"metadata": {},
|
|
64
|
+
"source": [
|
|
65
|
+
"The backend has a rather large number of modules all of which can operate mostly independently.\n",
|
|
66
|
+
"If changing only some of them, we could simiply copy-and-paste the code which instantiates and composes all of them, and switch out those we want to change.\n",
|
|
67
|
+
"However, this would not be well-maintainable: If a future version improves or restructures any part of the frontend, or if we want to allow the combination\n",
|
|
68
|
+
"of different modifications at different modules of the frontend, this idea very quickly reaches its limitations.\n",
|
|
69
|
+
"\n",
|
|
70
|
+
"So instead, also the frontend is made modular. It is exposed in form of \"configuration-class\" which implement getters for (many) different (sub-)modules in\n",
|
|
71
|
+
"in the backend. These (sub-)modules are constructed and composed with other (sub-)modules obtained in turn through other getters.\n",
|
|
72
|
+
"This means, any (sub-)modul can simply be swapped out by replacing its getter! All other (sub-)modules connecting to this component will\n",
|
|
73
|
+
"automatically get \"rewired\" as they call only the (new) getter to access this component.\n",
|
|
74
|
+
"\n",
|
|
75
|
+
"Put simply, if we want for example to replace PCMCI+ by LPCMCI, we can simply start from the \"default\" timer-series configuration,\n",
|
|
76
|
+
"and replace the \"universal CD\" getter.\n",
|
|
77
|
+
"Indeed in this case (see the documentation of bridges.tigramite.alg_lpcmci), we also have to switch out the\n",
|
|
78
|
+
"HCCD-controller. But this can be achieved just as easily."
|
|
79
|
+
]
|
|
80
|
+
},
|
|
81
|
+
{
|
|
82
|
+
"cell_type": "code",
|
|
83
|
+
"execution_count": 5,
|
|
84
|
+
"id": "299e7825",
|
|
85
|
+
"metadata": {},
|
|
86
|
+
"outputs": [],
|
|
87
|
+
"source": [
|
|
88
|
+
"class ConfigureHCCD_LPCMCI(GLDF.frontend.ConfigureHCCD):\n",
|
|
89
|
+
" def __init__(self, regimes_are_large: bool=True, alpha: float=0.01, alpha_pc1: float=0.1):\n",
|
|
90
|
+
" ts_config = GLDF.frontend.configure_hccd_temporal_regimes(regimes_are_large=regimes_are_large, alpha=alpha, alpha_pc1=alpha_pc1)\n",
|
|
91
|
+
" from dataclasses import asdict\n",
|
|
92
|
+
" super().__init__(**asdict(ts_config))\n",
|
|
93
|
+
" \n",
|
|
94
|
+
"\n",
|
|
95
|
+
" def get_universal_cd(self) -> GLDF.hccd.abstract_cd_t:\n",
|
|
96
|
+
" return GLDF.bridges.tigramite.alg_lpcmci(data_format=self.get_data_manager())\n",
|
|
97
|
+
"\n",
|
|
98
|
+
" def get_controller(self) ->GLDF.hccd.Controller:\n",
|
|
99
|
+
" return GLDF.hccd.ControllerTimeseriesLPCMCI(universal_cd=self.get_universal_cd(), testing_backend=self.get_transitionable_backend(), state_space_construction=self.get_state_space_construction())"
|
|
100
|
+
]
|
|
101
|
+
},
|
|
102
|
+
{
|
|
103
|
+
"cell_type": "markdown",
|
|
104
|
+
"id": "7001797c",
|
|
105
|
+
"metadata": {},
|
|
106
|
+
"source": [
|
|
107
|
+
"That's it already. After generating data, we can simply create an instance of this configuration and run it on the data."
|
|
108
|
+
]
|
|
109
|
+
},
|
|
110
|
+
{
|
|
111
|
+
"cell_type": "code",
|
|
112
|
+
"execution_count": 8,
|
|
113
|
+
"id": "50e8eb43",
|
|
114
|
+
"metadata": {},
|
|
115
|
+
"outputs": [],
|
|
116
|
+
"source": [
|
|
117
|
+
"import numpy as np\n",
|
|
118
|
+
"\n",
|
|
119
|
+
"N = 1000\n",
|
|
120
|
+
"\n",
|
|
121
|
+
"R = np.zeros(N, dtype=bool)\n",
|
|
122
|
+
"R[int(N/2):] = True\n",
|
|
123
|
+
"\n",
|
|
124
|
+
"rng = np.random.default_rng()\n",
|
|
125
|
+
"X_noise = rng.standard_normal(N)\n",
|
|
126
|
+
"Y_noise = rng.standard_normal(N)\n",
|
|
127
|
+
"Z_noise = rng.standard_normal(N)\n",
|
|
128
|
+
"L_noise = rng.standard_normal(N)\n",
|
|
129
|
+
"W_noise = rng.standard_normal(N)\n",
|
|
130
|
+
"\n",
|
|
131
|
+
"X = np.empty_like(X_noise)\n",
|
|
132
|
+
"Y = np.empty_like(Y_noise)\n",
|
|
133
|
+
"Z = np.empty_like(Z_noise)\n",
|
|
134
|
+
"L = np.empty_like(L_noise)\n",
|
|
135
|
+
"W = np.empty_like(W_noise)\n",
|
|
136
|
+
"\n",
|
|
137
|
+
"def lag_one_or_zero(values, t):\n",
|
|
138
|
+
" return values[t-1] if t > 0 else 0.0\n",
|
|
139
|
+
"\n",
|
|
140
|
+
"for t in range(N):\n",
|
|
141
|
+
" # latent\n",
|
|
142
|
+
" L[t] = L_noise[t] # + 0.25 * lag_one_or_zero(L, t)\n",
|
|
143
|
+
" # observables:\n",
|
|
144
|
+
" W[t] = W_noise[t] + 0.15 * lag_one_or_zero(W, t)\n",
|
|
145
|
+
" X[t] = X_noise[t] + 0.2 * lag_one_or_zero(X, t) - 0.7 * lag_one_or_zero(W, t) + 1.2 * L[t]\n",
|
|
146
|
+
" Z[t] = Z_noise[t]\n",
|
|
147
|
+
" Y[t] = Y_noise[t] + R[t] * lag_one_or_zero(X, t) + Z[t] + 0.8 * lag_one_or_zero(L, t)\n",
|
|
148
|
+
"\n",
|
|
149
|
+
"data = np.array([X,Y,Z,W]).T\n",
|
|
150
|
+
"var_names = [\"X\", \"Y\", \"Z\", \"W\"]"
|
|
151
|
+
]
|
|
152
|
+
},
|
|
153
|
+
{
|
|
154
|
+
"cell_type": "markdown",
|
|
155
|
+
"id": "a10823d6",
|
|
156
|
+
"metadata": {},
|
|
157
|
+
"source": [
|
|
158
|
+
"Regime-detection with latents in time-series is still experimental, in particular it may have low recall on regimes.\n",
|
|
159
|
+
"For example commenting in the auto-lag on L in the example above leads to problems. The deeper problem is not necessarily\n",
|
|
160
|
+
"related to auto-lagged confounders, but they provide one example why time-series causal-discovery with latents\n",
|
|
161
|
+
"in general is a very complex and difficult problem."
|
|
162
|
+
]
|
|
163
|
+
},
|
|
164
|
+
{
|
|
165
|
+
"cell_type": "code",
|
|
166
|
+
"execution_count": 9,
|
|
167
|
+
"id": "fda65558",
|
|
168
|
+
"metadata": {},
|
|
169
|
+
"outputs": [],
|
|
170
|
+
"source": [
|
|
171
|
+
"import numpy as np\n",
|
|
172
|
+
"\n",
|
|
173
|
+
"N = 1000\n",
|
|
174
|
+
"\n",
|
|
175
|
+
"R = np.zeros(N, dtype=bool)\n",
|
|
176
|
+
"R[int(N/2):] = True\n",
|
|
177
|
+
"\n",
|
|
178
|
+
"rng = np.random.default_rng()\n",
|
|
179
|
+
"L = rng.standard_normal(N)\n",
|
|
180
|
+
"W = rng.standard_normal(N)\n",
|
|
181
|
+
"X = rng.standard_normal(N) + L + W\n",
|
|
182
|
+
"Z = rng.standard_normal(N)\n",
|
|
183
|
+
"Y = rng.standard_normal(N) + L + R * Z\n",
|
|
184
|
+
"\n",
|
|
185
|
+
"data = np.array([X,Y,Z,W]).T\n",
|
|
186
|
+
"var_names = [\"X\", \"Y\", \"Z\", \"W\"]"
|
|
187
|
+
]
|
|
188
|
+
},
|
|
189
|
+
{
|
|
190
|
+
"cell_type": "code",
|
|
191
|
+
"execution_count": 10,
|
|
192
|
+
"id": "3c3876ca",
|
|
193
|
+
"metadata": {},
|
|
194
|
+
"outputs": [],
|
|
195
|
+
"source": [
|
|
196
|
+
"config = ConfigureHCCD_LPCMCI()\n",
|
|
197
|
+
"result = config.run(data)"
|
|
198
|
+
]
|
|
199
|
+
},
|
|
200
|
+
{
|
|
201
|
+
"cell_type": "code",
|
|
202
|
+
"execution_count": 11,
|
|
203
|
+
"id": "647d5348",
|
|
204
|
+
"metadata": {},
|
|
205
|
+
"outputs": [
|
|
206
|
+
{
|
|
207
|
+
"data": {
|
|
208
|
+
"image/png": "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",
|
|
209
|
+
"text/plain": [
|
|
210
|
+
"<Figure size 400x400 with 1 Axes>"
|
|
211
|
+
]
|
|
212
|
+
},
|
|
213
|
+
"metadata": {},
|
|
214
|
+
"output_type": "display_data"
|
|
215
|
+
},
|
|
216
|
+
{
|
|
217
|
+
"data": {
|
|
218
|
+
"image/png": "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",
|
|
219
|
+
"text/plain": [
|
|
220
|
+
"<Figure size 640x480 with 1 Axes>"
|
|
221
|
+
]
|
|
222
|
+
},
|
|
223
|
+
"metadata": {},
|
|
224
|
+
"output_type": "display_data"
|
|
225
|
+
}
|
|
226
|
+
],
|
|
227
|
+
"source": [
|
|
228
|
+
"import matplotlib.pyplot as plt\n",
|
|
229
|
+
"result.var_names = var_names\n",
|
|
230
|
+
"result.plot_labeled_union_graph()\n",
|
|
231
|
+
"plt.show()\n",
|
|
232
|
+
"for mi in result.model_indicators():\n",
|
|
233
|
+
" mi.plot_resolution()\n",
|
|
234
|
+
" plt.show()"
|
|
235
|
+
]
|
|
236
|
+
},
|
|
237
|
+
{
|
|
238
|
+
"cell_type": "markdown",
|
|
239
|
+
"id": "032bb099",
|
|
240
|
+
"metadata": {},
|
|
241
|
+
"source": [
|
|
242
|
+
"## 2. Spatial Regimes with PC-stable\n",
|
|
243
|
+
"\n",
|
|
244
|
+
"In the first tutorial, we ran an example with spatial regimes and FCI (allowing for latent confounding).\n",
|
|
245
|
+
"Here we re-configure the setup to run with PC-stable (no latent confounding).\n",
|
|
246
|
+
"\n",
|
|
247
|
+
"As in the first part, we copy a default configuration (in this case configure_hccd_spatial_regimes) and replace the\n",
|
|
248
|
+
"universal-cd module."
|
|
249
|
+
]
|
|
250
|
+
},
|
|
251
|
+
{
|
|
252
|
+
"cell_type": "code",
|
|
253
|
+
"execution_count": 12,
|
|
254
|
+
"id": "1bd2f284",
|
|
255
|
+
"metadata": {},
|
|
256
|
+
"outputs": [],
|
|
257
|
+
"source": [
|
|
258
|
+
"class ConfigureHCCD_PCstable(GLDF.frontend.ConfigureHCCD):\n",
|
|
259
|
+
" def __init__(self, regimes_are_large: bool=True, alpha: float=0.01):\n",
|
|
260
|
+
" std_config = GLDF.frontend.configure_hccd_spatial_regimes(regimes_are_large=regimes_are_large, alpha=alpha)\n",
|
|
261
|
+
" from dataclasses import asdict\n",
|
|
262
|
+
" super().__init__(**asdict(std_config)) \n",
|
|
263
|
+
"\n",
|
|
264
|
+
" def get_universal_cd(self) -> GLDF.hccd.abstract_cd_t:\n",
|
|
265
|
+
" return GLDF.bridges.causal_learn.alg_pc_stable(data_format=self.get_data_manager())"
|
|
266
|
+
]
|
|
267
|
+
},
|
|
268
|
+
{
|
|
269
|
+
"cell_type": "markdown",
|
|
270
|
+
"id": "0678b4c1",
|
|
271
|
+
"metadata": {},
|
|
272
|
+
"source": [
|
|
273
|
+
"We use the same data-generation as in the first tutorial:"
|
|
274
|
+
]
|
|
275
|
+
},
|
|
276
|
+
{
|
|
277
|
+
"cell_type": "code",
|
|
278
|
+
"execution_count": 13,
|
|
279
|
+
"id": "4b94533c",
|
|
280
|
+
"metadata": {},
|
|
281
|
+
"outputs": [
|
|
282
|
+
{
|
|
283
|
+
"name": "stdout",
|
|
284
|
+
"output_type": "stream",
|
|
285
|
+
"text": [
|
|
286
|
+
"(100, 100, 4)\n"
|
|
287
|
+
]
|
|
288
|
+
}
|
|
289
|
+
],
|
|
290
|
+
"source": [
|
|
291
|
+
"import numpy as np\n",
|
|
292
|
+
"\n",
|
|
293
|
+
"def get_data(seed=None):\n",
|
|
294
|
+
" data_size = (100, 100)\n",
|
|
295
|
+
" A = np.full(data_size, False)\n",
|
|
296
|
+
" A[:50,:] = True\n",
|
|
297
|
+
" B = np.full(data_size, False)\n",
|
|
298
|
+
" B[:,:50] = True\n",
|
|
299
|
+
"\n",
|
|
300
|
+
" rng = np.random.default_rng(seed=seed)\n",
|
|
301
|
+
"\n",
|
|
302
|
+
" X = rng.standard_normal(data_size)\n",
|
|
303
|
+
" Y = rng.standard_normal(data_size)\n",
|
|
304
|
+
" L = rng.standard_normal(data_size) # latent\n",
|
|
305
|
+
" Z = rng.standard_normal(data_size) + A * X + L\n",
|
|
306
|
+
" W = rng.standard_normal(data_size) + Y + B * L\n",
|
|
307
|
+
"\n",
|
|
308
|
+
" return np.array([X,Y,Z,W]).transpose([1,2,0])\n",
|
|
309
|
+
"\n",
|
|
310
|
+
"var_names = [\"X\", \"Y\", \"Z\", \"W\"]\n",
|
|
311
|
+
"data = get_data(seed=17062025)\n",
|
|
312
|
+
"print(data.shape)"
|
|
313
|
+
]
|
|
314
|
+
},
|
|
315
|
+
{
|
|
316
|
+
"cell_type": "markdown",
|
|
317
|
+
"id": "07765b97",
|
|
318
|
+
"metadata": {},
|
|
319
|
+
"source": [
|
|
320
|
+
"**Note:** This example *does* contain latent confounding. Here this leads to orientation-conflicts (x-markings in graph). In general there is of course no guarantee that inconsistencies with assumptions will be found."
|
|
321
|
+
]
|
|
322
|
+
},
|
|
323
|
+
{
|
|
324
|
+
"cell_type": "code",
|
|
325
|
+
"execution_count": 15,
|
|
326
|
+
"id": "9ca17510",
|
|
327
|
+
"metadata": {},
|
|
328
|
+
"outputs": [
|
|
329
|
+
{
|
|
330
|
+
"data": {
|
|
331
|
+
"image/png": "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",
|
|
332
|
+
"text/plain": [
|
|
333
|
+
"<Figure size 400x400 with 1 Axes>"
|
|
334
|
+
]
|
|
335
|
+
},
|
|
336
|
+
"metadata": {},
|
|
337
|
+
"output_type": "display_data"
|
|
338
|
+
},
|
|
339
|
+
{
|
|
340
|
+
"data": {
|
|
341
|
+
"image/png": "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",
|
|
342
|
+
"text/plain": [
|
|
343
|
+
"<Figure size 640x480 with 1 Axes>"
|
|
344
|
+
]
|
|
345
|
+
},
|
|
346
|
+
"metadata": {},
|
|
347
|
+
"output_type": "display_data"
|
|
348
|
+
},
|
|
349
|
+
{
|
|
350
|
+
"data": {
|
|
351
|
+
"image/png": "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",
|
|
352
|
+
"text/plain": [
|
|
353
|
+
"<Figure size 640x480 with 1 Axes>"
|
|
354
|
+
]
|
|
355
|
+
},
|
|
356
|
+
"metadata": {},
|
|
357
|
+
"output_type": "display_data"
|
|
358
|
+
}
|
|
359
|
+
],
|
|
360
|
+
"source": [
|
|
361
|
+
"config = ConfigureHCCD_PCstable()\n",
|
|
362
|
+
"result = config.run(data)\n",
|
|
363
|
+
"\n",
|
|
364
|
+
"result.var_names = var_names\n",
|
|
365
|
+
"result.plot_labeled_union_graph()\n",
|
|
366
|
+
"plt.show()\n",
|
|
367
|
+
"for mi in result.model_indicators():\n",
|
|
368
|
+
" mi.plot_resolution()\n",
|
|
369
|
+
" plt.show()"
|
|
370
|
+
]
|
|
371
|
+
}
|
|
372
|
+
],
|
|
373
|
+
"metadata": {
|
|
374
|
+
"kernelspec": {
|
|
375
|
+
"display_name": ".venv",
|
|
376
|
+
"language": "python",
|
|
377
|
+
"name": "python3"
|
|
378
|
+
},
|
|
379
|
+
"language_info": {
|
|
380
|
+
"codemirror_mode": {
|
|
381
|
+
"name": "ipython",
|
|
382
|
+
"version": 3
|
|
383
|
+
},
|
|
384
|
+
"file_extension": ".py",
|
|
385
|
+
"mimetype": "text/x-python",
|
|
386
|
+
"name": "python",
|
|
387
|
+
"nbconvert_exporter": "python",
|
|
388
|
+
"pygments_lexer": "ipython3",
|
|
389
|
+
"version": "3.13.5"
|
|
390
|
+
}
|
|
391
|
+
},
|
|
392
|
+
"nbformat": 4,
|
|
393
|
+
"nbformat_minor": 5
|
|
394
|
+
}
|