From 681c2553fc58cc816a0bb6fc4e57bcc332b1838c Mon Sep 17 00:00:00 2001 From: Roman Date: Sat, 5 Feb 2022 19:34:48 +0300 Subject: [PATCH] pre-alpha --- .gitignore | 1 + Networks.py | 31 +- Nodes.py | 135 +-- Tests/ConditionalGaussiansTest.py | 2 + Tests/HybridTest1.py | 4 - Tests/MetricsTest.py | 25 +- Tests/classifiersPickle.py | 2 + config.py | 14 + log.py | 18 +- logging.conf | 2 +- tutorials/ParametersLearningAndSampling.ipynb | 866 +++++++++++++++++- 11 files changed, 960 insertions(+), 140 deletions(-) create mode 100644 config.py diff --git a/.gitignore b/.gitignore index 7b2ce99..51ffb12 100644 --- a/.gitignore +++ b/.gitignore @@ -3,4 +3,5 @@ *\.ipynb_checkpoints __pycache__/ *.log +*.ini diff --git a/Networks.py b/Networks.py index 0e1aa5d..a36002f 100644 --- a/Networks.py +++ b/Networks.py @@ -8,7 +8,9 @@ import pandas as pd import numpy as np import json +import os +from tqdm import tqdm from concurrent.futures import ThreadPoolExecutor from Utils import GraphUtils as gru from pyvis.network import Network @@ -17,7 +19,9 @@ from Builders import ParamDict from log import logger_network +from config import config +STORAGE = config.get('NODES', 'models_storage', fallback='models_storage is not defined') class BaseNetwork(object): """ @@ -40,6 +44,7 @@ def __init__(self): self.has_logit = False self.use_mixture = False + @property def nodes_names(self) -> List[str]: return [node.name for node in self.nodes] @@ -81,7 +86,7 @@ def add_nodes(self, descriptor: Dict[str, Dict[str, str]]): self.nodes = worker_1.vertices def add_edges(self, data: pd.DataFrame, scoring_function: Union[Tuple[str, Callable], Tuple[str]], - classifier: object = None, + classifier: Optional[object] = None, params: Optional[ParamDict] = None, optimizer: str = 'HC'): """ Base function for Structure learning @@ -91,7 +96,7 @@ def add_edges(self, data: pd.DataFrame, scoring_function: Union[Tuple[str, Calla remove_init_edges: allows changes in model defined by user white_list: list of allowed edges """ - if not self.has_logit: + if not self.has_logit and classifier: logger_network.error("Classifiers dict will be ignored since logit nodes are forbidden.") return None @@ -143,6 +148,7 @@ def get_params_tree(self, outdir: str): return None with open(outdir, 'w+') as out: json.dump(self.distributions, out) + return True def fit_parameters(self, data: pd.DataFrame, dropna: bool = True): """ @@ -152,6 +158,16 @@ def fit_parameters(self, data: pd.DataFrame, dropna: bool = True): data = data.dropna() data.reset_index(inplace=True, drop=True) + if self.has_logit: + if any(['Logit' in node.type for node in self.nodes]): + if not os.path.isdir(STORAGE): + os.makedirs(os.path.join(STORAGE, "0")) + elif os.listdir(STORAGE): + index = sorted( + [int(id) for id in os.listdir(STORAGE)] + )[-1] + 1 + os.makedirs(os.path.join(STORAGE, str(index))) + # Turn all discrete values to str for learning algorithm if 'disc_num' in self.descriptor['types'].values(): columns_names = [name for name, t in self.descriptor['types'].items() if t in ['disc_num']] @@ -179,7 +195,6 @@ def get_info(self, as_df: bool = True) -> Optional[pd.DataFrame]: types_d = [] parents = [] parents_types = [] - import pandas as pd for n in self.nodes: names.append(n) types_n.append(n.type) @@ -229,7 +244,6 @@ def sample(self, n: int, evidence: Optional[Dict[str, Union[str, int, float]]] = return seq def predict(self, test: pd.DataFrame, parall_count: int = 1) -> Dict[str, Union[List[str], List[int], List[float]]]: - from joblib import Parallel, delayed """ Function to predict columns from given data. Note that train data and test data must have different columns. @@ -242,23 +256,22 @@ def predict(self, test: pd.DataFrame, parall_count: int = 1) -> Dict[str, Union[ Returns: predicted data (dict): dict with column as key and predicted data as value """ + from joblib import Parallel, delayed def wrapper(bn: HybridBN, test: pd.DataFrame, columns: List[str]): preds = {column_name: list() for column_name in columns} if len(test) == 1: for i in range(test.shape[0]): - print(i) test_row = dict(test.iloc[i, :]) for n, key in enumerate(columns): try: + sample = bn.sample(2000, evidence=test_row) if bn[key].type.startswith(('Discrete', 'Logit', 'ConditionalLogit',)): - sample = self.sample(2000, evidence=test_row) count_stats = sample[key].value_counts() preds[key].append(count_stats.index[0]) else: - sample = bn.sample(2000, evidence=test_row) - if self.descriptor['signs'][key] == 'pos': + if bn.descriptor['signs'][key] == 'pos': sample = sample.loc[sample[key] >= 0] if sample.shape[0] == 0: preds[key].append(np.nan) @@ -281,7 +294,7 @@ def wrapper(bn: HybridBN, test: pd.DataFrame, columns: List[str]): preds = {column_name: list() for column_name in columns} processed_list = Parallel(n_jobs=parall_count)( - delayed(wrapper)(self, test.loc[[i]], columns) for i in test.index) + delayed(wrapper)(self, test.loc[[i]], columns) for i in tqdm(test.index, position=0, leave=True)) for i in range(test.shape[0]): curr_pred = processed_list[i] diff --git a/Nodes.py b/Nodes.py index 6e041f0..39cef0d 100644 --- a/Nodes.py +++ b/Nodes.py @@ -11,9 +11,13 @@ import itertools import random import joblib +import pickle import os from log import logger_nodes +from config import config + +STORAGE = config.get('NODES', 'models_storage', fallback='models_storage is not defined') class DiscreteParams(TypedDict): @@ -44,6 +48,17 @@ def __init__(self, name: str): def __repr__(self): return f"{self.name}" + @staticmethod + def choose_serialization(model) -> Union[str, Exception]: + try: + ex_b = pickle.dumps(model, protocol=4) + model_ser = ex_b.decode('latin1').replace('\'', '\"') + a = model_ser.replace('\"', '\'').encode('latin1') + classifier_body = pickle.loads(a) + return 'pickle' + except Exception as ex: + return ex + class DiscreteNode(BaseNode): """ @@ -463,7 +478,8 @@ def choose(node_info: Dict[str, Dict[str, CondMixtureGaussParams]], class LogitParams(TypedDict): classes: List[int] classifier: str - classifier_obj: Optional[Union[str, bool, object]] + classifier_obj: Optional[Union[str, bool, bytes]] + serialization: str class LogitNode(BaseNode): @@ -479,28 +495,33 @@ def __init__(self, name, classifier: Optional[object] = None): self.type = 'Logit' + f" ({type(self.classifier).__name__})" def fit_parameters(self, data: DataFrame) -> LogitParams: - if not os.path.isdir(f"{self.name.replace(' ', '_')}"): - os.mkdir(f"{self.name.replace(' ', '_')}") parents = self.disc_parents + self.cont_parents self.classifier.fit(data[parents].values, data[self.name].values) - # Saving model by serializing it with Joblib module - try: - path = os.path.abspath(f"{self.name.replace(' ', '_')}/{self.name.replace(' ', '_')}.joblib.compressed") - joblib.dump(self.classifier, path, compress=True, protocol=4) - model_ser = joblib.load(path) - except Exception as ex: - path = False - logger_nodes.warning( - f"{self.name}::Joblib failed. BAMT will save entire model as python object. | " + ex.args[0]) + serialization = self.choose_serialization(self.classifier) - if path: + if serialization == 'pickle': + ex_b = pickle.dumps(self.classifier, protocol=4) + # model_ser = ex_b.decode('latin1').replace('\'', '\"') + model_ser = ex_b.decode('latin1') return {'classes': list(self.classifier.classes_), - 'classifier_obj': path, - 'classifier': type(self.classifier).__name__} + 'classifier_obj': model_ser, + 'classifier': type(self.classifier).__name__, + 'serialization': 'pickle'} else: + logger_nodes.warning(f"{self.name}::Pickle failed. BAMT will use Joblib. | " + str(serialization.args[0])) + index = str(int(os.listdir(STORAGE)[-1])) + if not os.path.isdir(os.path.join(STORAGE, index, f"{self.name.replace(' ', '_')}")): + os.makedirs(os.path.join(STORAGE, index, f"{self.name.replace(' ', '_')}")) + path = os.path.abspath(os.path.join(STORAGE, + index, + f"{self.name.replace(' ', '_')}", + f"{self.name.replace(' ', '_')}.joblib.compressed")) + + joblib.dump(self.classifier, path, compress=True, protocol=4) return {'classes': list(self.classifier.classes_), - 'classifier_obj': self.classifier, - 'classifier': type(self.classifier).__name__} + 'classifier_obj': path, + 'classifier': type(self.classifier).__name__, + 'serialization': 'joblib'} def choose(self, node_info: LogitParams, pvals: List[Union[str, float]]) -> str: """ @@ -512,12 +533,14 @@ def choose(self, node_info: LogitParams, pvals: List[Union[str, float]]) -> str: pvals = [str(p) for p in pvals] rindex = 0 - # JOBLIB + if len(node_info["classes"]) > 1: - if isinstance(node_info["classifier_obj"], str): + if node_info["serialization"] == 'joblib': model = joblib.load(node_info["classifier_obj"]) else: - model = node_info["classifier_obj"] + # str_model = node_info["classifier_obj"].decode('latin1').replace('\'', '\"') + a = node_info["classifier_obj"].encode('latin1') + model = pickle.loads(a) distribution = model.predict_proba(np.array(pvals).reshape(1, -1))[0] @@ -557,8 +580,6 @@ def fit_parameters(self, data: DataFrame) -> Dict[str, Dict[str, LogitParams]]: Return: {"hybcprob": { : LogitParams}} """ - if not os.path.isdir(f"{self.name.replace(' ', '_')}"): - os.mkdir(f"{self.name.replace(' ', '_')}") hycprob = dict() values = [] combinations = [] @@ -578,46 +599,43 @@ def fit_parameters(self, data: DataFrame) -> Dict[str, Dict[str, LogitParams]]: model = self.classifier values = set(new_data[self.name]) if len(values) > 1: - if self.name == 'Period' or comb in [['BACKARC', 'LIMESTONE'], ['BACKARC', 'LOW-RESISTIVITY SANDSTONE']]: - # print('BP') - pass model.fit(new_data[self.cont_parents].values, new_data[self.name].values) - classes = model.classes_ - # Saving model by serializing it with Pickle module - # try: - # ex_b = pickle.dumps(model, protocol=4) - # model_ser = ex_b.decode('latin1').replace('\'', '\"') - # a = model_ser.replace('\"', '\'').encode('latin1') - # classifier_body = pickle.loads(a) - # model = None # clear memory - # except Exception as ex: - # model_ser = False - # logger_nodes.warning( - # f"{self.name} {comb}::Pickle failed. BAMT will save entire model as python object. | " + - # ex.args[ - # 0]) - try: - path = os.path.abspath(f"{self.name.replace(' ', '_')}/{str(key_comb)}.joblib.compressed") - joblib.dump(self.classifier, path, compress=True, protocol=4) - model_ser = joblib.load(path) - except Exception as ex: - path = False + classes = list(model.classes_) + serialization = self.choose_serialization(model) + + if serialization == 'pickle': + ex_b = pickle.dumps(self.classifier, protocol=4) + model_ser = ex_b.decode('latin1') + + # model_ser = pickle.dumps(self.classifier, protocol=4) + hycprob[str(key_comb)] = {'classes': classes, + 'classifier_obj': model_ser, + 'classifier': type(self.classifier).__name__, + 'serialization': 'pickle'} + else: logger_nodes.warning( - f"{self.name} {comb}::Joblib failed. BAMT will save entire model as python object. | " + - ex.args[0]) + f"{self.name} {comb}::Pickle failed. BAMT will use Joblib. | " + str(serialization.args[0])) + index = str(int(os.listdir(STORAGE)[-1])) + if not os.path.isdir(os.path.join(STORAGE, index, f"{self.name.replace(' ', '_')}")): + os.makedirs(os.path.join(STORAGE, index, f"{self.name.replace(' ', '_')}")) + path = os.path.abspath(os.path.join(STORAGE, + index, + f"{self.name.replace(' ', '_')}", + f"{comb}.joblib.compressed")) + + joblib.dump(model, path, compress=True, protocol=4) + hycprob[str(key_comb)] = {'classes': classes, + 'classifier_obj': path, + 'classifier': type(self.classifier).__name__, + 'serialization': 'joblib'} else: - path = 'unknown' classes = list(values) + hycprob[str(key_comb)] = {'classes': classes, 'classifier': type(self.classifier).__name__, + 'classifier_obj': None, 'serialization': None} - if not path: - hycprob[str(key_comb)] = {'classes': list(classes), 'classifier': type(model).__name__, - 'classifier_obj': model} - else: - hycprob[str(key_comb)] = {'classes': list(classes), 'classifier': type(model).__name__, - 'classifier_obj': path} else: hycprob[str(key_comb)] = {'classes': list(classes), 'classifier': type(self.classifier).__name__, - 'classifier_obj': None} + 'classifier_obj': None, 'serialization': None} return {"hybcprob": hycprob} def choose(self, node_info: Dict[str, Dict[str, LogitParams]], pvals: List[Union[str, float]]) -> str: @@ -640,11 +658,12 @@ def choose(self, node_info: Dict[str, Dict[str, LogitParams]], pvals: List[Union # JOBLIB if len(lgdistribution["classes"]) > 1: - if isinstance(lgdistribution["classifier_obj"], str): + if lgdistribution["serialization"] == 'joblib': model = joblib.load(lgdistribution["classifier_obj"]) else: - model = lgdistribution["classifier_obj"] - + # str_model = lgdistribution["classifier_obj"].decode('latin1').replace('\'', '\"') + bytes_model = lgdistribution["classifier_obj"].encode('latin1') + model = pickle.loads(bytes_model) distribution = model.predict_proba(np.array(lgpvals).reshape(1, -1))[0] diff --git a/Tests/ConditionalGaussiansTest.py b/Tests/ConditionalGaussiansTest.py index 5b0b9dc..e73e2b8 100644 --- a/Tests/ConditionalGaussiansTest.py +++ b/Tests/ConditionalGaussiansTest.py @@ -47,6 +47,8 @@ t2 = time.time() print(f'PL elaspsed: {t2 - t1}') +bn.get_params_tree("final.json") + # # bn.plot('Hybrid_hackp') # for num, el in enumerate(bn.sample(10, as_df=False), 1): # print('\n', num) diff --git a/Tests/HybridTest1.py b/Tests/HybridTest1.py index e55acc7..1c62cc6 100644 --- a/Tests/HybridTest1.py +++ b/Tests/HybridTest1.py @@ -78,7 +78,3 @@ print(f'PL elaspsed: {t2-t1}') # for node, d in bn.distributions.items(): # print(node,":", d) - -import json -with open("../test_hybrid_out.json", 'w+') as out: - json.dump(bn.distributions, out) \ No newline at end of file diff --git a/Tests/MetricsTest.py b/Tests/MetricsTest.py index b0ca6e0..dd97cb3 100644 --- a/Tests/MetricsTest.py +++ b/Tests/MetricsTest.py @@ -13,8 +13,6 @@ from sklearn import preprocessing as pp import Networks -# import Metrics - p1 = time.time() print(f"Time elapsed for importing: {p1 - start}") @@ -47,7 +45,7 @@ t2 = time.time() print(f'PL elapsed: {t2 - t1}') -columns = ['Tectonic regime', 'Period', 'Gross'] +columns = ['Lithology', 'Structural setting', 'Porosity', 'Depth'] validY = h[columns].dropna() validX = h.drop(columns, axis=1).dropna() @@ -55,24 +53,3 @@ pred_param = bn.predict(validX.iloc[0:20, :], parall_count=3) time_2 = time.time() print(f'Predict elapsed: {time_2 - time_1}') - -# sync -# with matrix: 102.74379372596741 -# with dict: 80.4413230419159, 82.58527779579163 - -# async -# Threads = 1 -# Test for nan checker -# with for loop for columns: 88.78174304962158, 85.52139496803284 -# with no for loop for columns: 94.38896083831787 -# Threads = 2 -# 55.83470320701599 -# Threads = 3 -# 53.80153179168701, 49.15917134284973 - -from sklearn.metrics import accuracy_score, mean_squared_error - -for column in ['Tectonic regime', 'Period']: - print(column, round(accuracy_score(validY[column][0:20], pred_param[column]), 5)) - -print('Gross', round(mean_squared_error(validY['Gross'][0:20], pred_param['Gross'], squared=False), 5)) diff --git a/Tests/classifiersPickle.py b/Tests/classifiersPickle.py index 574704b..776771e 100644 --- a/Tests/classifiersPickle.py +++ b/Tests/classifiersPickle.py @@ -50,6 +50,8 @@ predictions_mi = bn.sample(514, as_df=True) bn.get_params_tree('final.json') +print('finished') + # successful = {} # failed = {} # for i in range(6): diff --git a/config.py b/config.py new file mode 100644 index 0000000..df3dc9a --- /dev/null +++ b/config.py @@ -0,0 +1,14 @@ +import configparser +from os import path + +config = configparser.ConfigParser() + +CONFIGFILE = path.join(path.dirname(path.abspath(__file__)), 'selbst.ini') +if path.isfile(CONFIGFILE): + config.read(CONFIGFILE) +else: + open(CONFIGFILE, 'a').close() + config['NODES'] = {'models_storage' : path.join(path.dirname(path.abspath(__file__)), 'Nodes_data')} + config['LOG'] = {"log_conf_loc" : path.join(path.dirname(path.abspath(__file__)), 'logging.conf')} + with open(CONFIGFILE, 'w') as configfile: + config.write(configfile) diff --git a/log.py b/log.py index 613442a..7b2bef4 100644 --- a/log.py +++ b/log.py @@ -1,7 +1,19 @@ import logging.config -from os import path -log_file_path = path.join(path.dirname(path.abspath(__file__)), 'logging.conf') -logging.config.fileConfig(log_file_path) +import os +from config import config +import warnings + +log_file_path = config.get('LOG', 'log_conf_loc', fallback='log_conf_path is not defined') + +if not os.path.isdir(os.path.join(os.path.expanduser("~"), 'BAMT')): + os.mkdir(os.path.join(os.path.expanduser("~"), 'BAMT')) + +try: + logging.config.fileConfig(log_file_path) +except: + log_file_path = os.path.join(path.dirname(os.path.abspath(__file__)), 'logging.conf') + logging.config.fileConfig(log_file_path) + warnings.warn("Reading log path location from config file failed. Default location will be used instead.") logger_builder = logging.getLogger('builder') diff --git a/logging.conf b/logging.conf index ebac3a3..2384be9 100644 --- a/logging.conf +++ b/logging.conf @@ -52,7 +52,7 @@ args=(sys.stdout,) class=FileHandler level=INFO formatter=simpleFormatter -args=("../general.log", 'a') +args=(os.path.expanduser("~") + '/BAMT/general.log', 'a') [formatter_simpleFormatter] format=%(asctime)s | %(levelname)-8s | %(filename)s-%(funcName)s-%(lineno)04d | %(message)s diff --git a/tutorials/ParametersLearningAndSampling.ipynb b/tutorials/ParametersLearningAndSampling.ipynb index f2eb1c3..a5a7f0b 100644 --- a/tutorials/ParametersLearningAndSampling.ipynb +++ b/tutorials/ParametersLearningAndSampling.ipynb @@ -57,7 +57,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Wall time: 5.7 s\n" + "Wall time: 5.66 s\n" ] } ], @@ -69,8 +69,15 @@ "\n", "import pandas as pd\n", "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", "from sklearn import preprocessing\n", - "import matplotlib.pyplot as plt" + "from sklearn.metrics import accuracy_score, mean_squared_error\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.neighbors import KNeighborsClassifier\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "\n", + "from pgmpy.estimators import K2Score" ] }, { @@ -456,7 +463,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2022-01-28 16:41:39,657 | ERROR | Networks.py-plot-0320 | This version allows only html format.\n" + "2022-02-05 17:33:42,923 | ERROR | Networks.py-plot-0333 | This version allows only html format.\n" ] } ], @@ -484,7 +491,7 @@ " " ], "text/plain": [ - "" + "" ] }, "execution_count": 11, @@ -539,12 +546,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "[Tectonic regime, Period, Lithology, Structural setting, Gross, Netpay, Porosity, Permeability, Depth]\n" + "['Tectonic regime', 'Period', 'Lithology', 'Structural setting', 'Gross', 'Netpay', 'Porosity', 'Permeability', 'Depth']\n" ] } ], "source": [ - "print(bn.nodes)" + "print(bn.nodes_names) # bn.nodes: List[Nodes]" ] }, { @@ -567,7 +574,7 @@ " " ], "text/plain": [ - "" + "" ] }, "execution_count": 13, @@ -617,7 +624,7 @@ " " ], "text/plain": [ - "" + "" ] }, "execution_count": 14, @@ -668,7 +675,7 @@ " " ], "text/plain": [ - "" + "" ] }, "execution_count": 15, @@ -719,7 +726,7 @@ " " ], "text/plain": [ - "" + "" ] }, "execution_count": 16, @@ -754,6 +761,14 @@ "What is going on inside each type of vertex can be found in special notebook (\"Nodes.ipynb\")

" ] }, + { + "cell_type": "markdown", + "id": "55beafa6", + "metadata": {}, + "source": [ + "### Sample() function" + ] + }, { "cell_type": "code", "execution_count": 17, @@ -764,7 +779,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2022-01-28 16:41:43,921 | ERROR | Networks.py-sample-0207 | Parameter learning wasn't done. Call fit_parameters method\n" + "2022-02-05 17:33:47,569 | ERROR | Networks.py-sample-0222 | Parameter learning wasn't done. Call fit_parameters method\n" ] } ], @@ -813,7 +828,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "654c3785e8dd43598afba470615fb45d", + "model_id": "6ac3aea2087347c68dfecdac648a8773", "version_major": 2, "version_minor": 0 }, @@ -826,11 +841,6 @@ } ], "source": [ - "from pgmpy.estimators import K2Score\n", - "from sklearn.ensemble import RandomForestClassifier\n", - "from sklearn.neighbors import KNeighborsClassifier\n", - "from sklearn.tree import DecisionTreeClassifier\n", - "\n", "bn_1.add_edges(discretized_data, scoring_function=('MI',))\n", "bn_1.set_classifiers(classifiers={'Structural setting': DecisionTreeClassifier(),\n", " 'Lithology': RandomForestClassifier(),\n", @@ -1137,7 +1147,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Wall time: 6.49 s\n" + "2022-02-05 17:33:53,216 | WARNING | Nodes.py-fit_parameters-0616 | Lithology ['FORELAND']::Pickle failed. BAMT will use Joblib. | invalid load key, '\\x00'.\n", + "Wall time: 3.35 s\n" ] } ], @@ -1156,7 +1167,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Wall time: 9.92 s\n" + "Wall time: 8.77 s\n" ] } ], @@ -1170,7 +1181,18 @@ "execution_count": 25, "id": "3f446fb2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "bn_1.get_params_tree('out.json')" ] @@ -1178,25 +1200,52 @@ { "cell_type": "code", "execution_count": 26, - "id": "d6d2d4e0", + "id": "ce080874", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wall time: 21.4 s\n" + ] + } + ], "source": [ - "predictions_mi = bn_1.sample(514, as_df=True)\n", - "predictions_k2 = bn_2.sample(514, as_df=True)" + "%%time\n", + "synth_data_mi = bn_1.sample(514, as_df=True)" ] }, { "cell_type": "code", "execution_count": 27, + "id": "33e4fe1e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wall time: 114 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "synth_data_k2 = bn_2.sample(514, as_df=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, "id": "af1bde59", "metadata": { - "scrolled": false + "scrolled": true }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "

" ] @@ -1208,7 +1257,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1220,7 +1269,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1232,7 +1281,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1244,7 +1293,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1256,7 +1305,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA14AAAI4CAYAAAB6AjgBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAoDklEQVR4nO3dfbSlZ1kn6N9tKgYEHBJTpGMSqEhH28Q1HZiaSA8zSgNjIkEDPdBT2NJxCRNXT1CcscdJdJbALNMrtl84o9gdPqOAMd2AxKS1CdE0w7QSKhgwH0QKUp0UiUkJpgHbDpNwzx/7LbMpTtU5Vec8dfauuq619jrvft6PfT/7nPc557ffj1PdHQAAAMb5us0uAAAA4GgneAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAHAYaqqH6qqDx/pdYGjl3Hl6CV4HcOqandVPVhVT5pre3VV3bzG9d9RVT87rMADv+4dVfWl6fFYVf3nuec/daTrgWW1rGPA9NrnVNUHquovq+rhqrq1ql60GbWMUFXbqqqr6mP7tZ9cVV+uqt1zbbur6oVHvEhYgXFlcc2NK1um51VV/3dVfbKqTquqC6vqw1Pf/7yq3lxVT9nsuo8mghdbkrx2s4s4FN19Tnc/ubufnOT/SfKafc+7+5/tW27fwAIc1NKNAZPfTXJjklOSPC3JjyX5wqZWNMaTquo75p7/QJJ7NqsYWCPjyoKrqkryL5M8L8l3d/dnk/wXSX42yTcn+fYkpyf5+c2q8WgkePHzSf5pVT11pZlV9Xeq6saq+nxV3V1V/3BqvyTJP0ryk9ORpt+d2ndX1eVVdef0idHbq+oJ07wTq+r6qto7zbu+qk6f5r28qm7d77V/oqp+Z60dmfsk51VVdW+SP6iq51XVnv2W+5tPh6vq66rqsqr6dFV9rqquraqT1vqacBRYujGgqk5OcmaSN3f3l6fH/9vdH17tdab5N1fVz1bVv99Xe1V9U1W9q6q+UFUfraptc8t3Vf1YVX2mqv6iqn6+qlb8/Xmg92ua901Vdd30Grckeeaq353kN5NcPPf8Hyf5jTWsB5vJuLLY48pxSd6RZHuS53X3g0nS3e/u7t/v7v/U3X+Z5M1JnruG7bFGghc7k9yc5J/uP6NmpwncmOTdmX3y84okb6qqc7r7qiTvSvLPpyNN3ze36j9Kcn5mO/+3Jvk/pvavS/L2JM9I8vQkf53kV6d51yU5s6q+fW47P5jZHx2H6rsz+6Tm/DUs+2NJXjKt881J/jLJrx3Ga8KyWsYx4HNJdiV5Z1W9pKpO2W/+wV5nnx1JXpnktKnOP5rWOSnJXUlet9/yL83sj5RnJ7koyQ/vX9TB3q9pkV9L8p+TnDqt/zXbWME7k+yoquOm9+YpST6yhvVgMxlXFntceVeSv5Pk+d39uYMs911J7ljD9lgjwYsk+ZkkP1pVW/drf3GS3d399u5+tLs/luQ9SV62yvZ+tbvv6+7PJ7kis0Ei3f257n7P9EnKF6d53z3NeyTJb2c2IGYaULYluf4w+vP67v6r7v7rNSz7I0l+urv3TDW8PsnLymmKHFuWagzo7k7y95PsTvKLSR6oqg9V1Vmrvc6ct3f3p7v7Pyb5vSSf7u4PdvejSf5Vkmftt/zPdffnu/veJG/c16e1vl9VdVyS/yHJz0zj0+1Jrl7lfUySPUnuTvLCzI58OdrFsjCuLO648j1Jru3uhw+0QFX995mNOT+zhu2xRoIXmXbU65Nctt+sZyT5zppdZPlwVT2c2SdOf2uVTd43N/0fMjuSlKr6hqr6l1X1H6rqC0k+lOSp08CRzAaLH6iqyuwTo2unQfNQ3bf6In/jGUneN9e/u5I8ltn53XBMWMYxYPqw5DXd/cypzr/KFErW8DpJ8uDc9F+v8PzJa+nTfg72fm3N7LqX/bezFr+R5Icy+6PsnWtcBzaVcWWhx5UXJ3ldVa14dKyqnpPZEbaXdfefrWF7rJHgxT6vS/I/ZXZ4fJ/7kvy77n7q3OPJ3f1Ppvl9gG2dMTf99CT3T9M/keTbknxnd39jZoewk6SSpLv/OMmXk/x3mV1AfjinGe5f118l+YZ9T6YBcv7Tt/uSfO9+fXzCdJEpHEuWdgzo7vsyO91m300oDvo6h+lAfZp3sPdrb5JHV9jOWrwnyYVJPtPdaw1rsAiMKwe3WePKv0/yfUl+pap+YH5GVT0rs1M0f7i7bzqEvrAGghdJku7eldnh+B+ba74+ybdW1Sur6vjp8V/PnSv9YJJvWWFzl1bV6TW7ScVPTdtNZtcm/HWSh6d5+5/rnMw+WfrVJI/2dEHrOv1ZkifU7Bapx2d2TvgJc/P/RZIrquoZSVJVW6vqog14XVgqyzQG1Owi9zdU1d+u2Q1yTs7suoY/PoTXOVT/2/S6Z2R2t7bfXmGZA75f3f1Ykvcmef30yfnZ+eqbZhxQd/9VkucnefUG9AOOGOPKqjZzXPl3Sf5Bkquq6mVJUrM7qP5+kh/t7t/dgP6xH8GLef9nkr/5vxvTOczfk9nFovcn+fMkP5fHg8tbk5w9Hfr+nbntvDvJB5J8Znrs+38cb0zyxCR/kdlA9vsr1PCbmX26dLhHu77KdJ71/5zkLUk+m9kRsPm7HP5KZp/sfKCqvjjV9Z0b8dqwhJZlDPhyZtdpfDCzWz3fnuSRzE7HW+vrHKr3J7k1yW1Jbsis719lDe/XazI71ejPM7uj2NvX+uLdvbO7P33Y1cPmMa4c2GaPKzcm+R+TvKOqvi+zo3pbk7y1Hv//qG6usYFqdi0hbIya/VPPV3f3Bw9z/ScmeSjJs7v7UxtZGzDe0TgGVFUnOWv69B44wowrHC0c8WLR/JMkH12UgRE44owBwEYzrrAQ3DKbhTF9olWZ/V8t4BhjDAA2mnGFReJUQwAAgMGcaggAADDYQpxqePLJJ/e2bds2uwxgE916661/0d1bV1/y0Bhf4NhmbAFGOdTxZSGC17Zt27Jz587NLgPYRFU15B/DGl/g2GZsAUY51PHFqYYAAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDbdnsAg7HtstuGLbt3VdeOGzbAADAsckRLwAAgMEELwAAgMEELwAAgMEELwAAgMEELwAAgMEELwAAgMEELwAAgMEELwAAgMEELwAAgMEELwAAgMEELwAAgMEELwAAgMEELwAAgMEELwAAgMEELwAAgMEELwAAgMEELwAAgMHWHLyq6riq+pOqun56flJV3VhVn5q+nji37OVVtauq7q6q80cUDgAAsCwO5YjXa5PcNff8siQ3dfdZSW6anqeqzk6yI8k5SS5I8qaqOm5jygUAAFg+awpeVXV6kguTvGWu+aIkV0/TVyd5yVz7Nd39SHffk2RXkvM2pFoAAIAltNYjXm9M8pNJvjLXdkp3P5Ak09enTe2nJblvbrk9UxsAAMAxadXgVVUvTvJQd9+6xm3WCm29wnYvqaqdVbVz7969a9w0wOqML8AIxhZgPdZyxOu5Sb6/qnYnuSbJ86vqnUkerKpTk2T6+tC0/J4kZ8ytf3qS+/ffaHdf1d3bu3v71q1b19EFgK9mfAFGMLYA67Fq8Oruy7v79O7eltlNM/6gu38wyXVJLp4WuzjJ+6fp65LsqKoTqurMJGcluWXDKwcAAFgSW9ax7pVJrq2qVyW5N8nLk6S776iqa5PcmeTRJJd292PrrhQAAGBJHVLw6u6bk9w8TX8uyQsOsNwVSa5YZ20AAABHhUP5P14AAAAcBsELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgMMELAABgsFWDV1U9oapuqaqPV9UdVfWGqf31VfXZqrpterxobp3Lq2pXVd1dVeeP7AAAAMCi27KGZR5J8vzu/lJVHZ/kw1X1e9O8X+7uX5hfuKrOTrIjyTlJvjnJB6vqW7v7sY0sHAAAYFmsesSrZ740PT1+evRBVrkoyTXd/Uh335NkV5Lz1l0pAADAklrTNV5VdVxV3ZbkoSQ3dvdHplmvqapPVNXbqurEqe20JPfNrb5natt/m5dU1c6q2rl3797D7wHAfowvwAjGFmA91hS8uvux7j43yelJzquq70jy60memeTcJA8k+cVp8VppEyts86ru3t7d27du3XoYpQOszPgCjGBsAdbjkO5q2N0PJ7k5yQXd/eAUyL6S5M15/HTCPUnOmFvt9CT3r79UAACA5bSWuxpuraqnTtNPTPLCJJ+sqlPnFntpktun6euS7KiqE6rqzCRnJbllQ6sGAABYImu5q+GpSa6uquMyC2rXdvf1VfWbVXVuZqcR7k7yI0nS3XdU1bVJ7kzyaJJL3dEQAAA4lq0avLr7E0metUL7Kw+yzhVJrlhfaQAAAEeHQ7rGCwAAgEMneAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAwmeAEAAAy2avCqqidU1S1V9fGquqOq3jC1n1RVN1bVp6avJ86tc3lV7aqqu6vq/JEdAAAAWHRrOeL1SJLnd/ffTXJukguq6jlJLktyU3efleSm6Xmq6uwkO5Kck+SCJG+qquMG1A4AALAUVg1ePfOl6enx06OTXJTk6qn96iQvmaYvSnJNdz/S3fck2ZXkvI0sGgAAYJms6Rqvqjquqm5L8lCSG7v7I0lO6e4HkmT6+rRp8dOS3De3+p6pbf9tXlJVO6tq5969e9fRBYCvZnwBRjC2AOuxpuDV3Y9197lJTk9yXlV9x0EWr5U2scI2r+ru7d29fevWrWsqFmAtjC/ACMYWYD0O6a6G3f1wkpszu3brwao6NUmmrw9Ni+1JcsbcaqcnuX+9hQIAACyrtdzVcGtVPXWafmKSFyb5ZJLrklw8LXZxkvdP09cl2VFVJ1TVmUnOSnLLBtcNAACwNLasYZlTk1w93Znw65Jc293XV9UfJbm2ql6V5N4kL0+S7r6jqq5NcmeSR5Nc2t2PjSkfAABg8a0avLr7E0metUL755K84ADrXJHkinVXBwAAcBQ4pGu8AAAAOHSCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCCFwAAwGCrBq+qOqOq/rCq7qqqO6rqtVP766vqs1V12/R40dw6l1fVrqq6u6rOH9kBAACARbdlDcs8muQnuvtjVfWUJLdW1Y3TvF/u7l+YX7iqzk6yI8k5Sb45yQer6lu7+7GNLBwAAGBZrHrEq7sf6O6PTdNfTHJXktMOsspFSa7p7ke6+54ku5KctxHFAgAALKNDusarqrYleVaSj0xNr6mqT1TV26rqxKnttCT3za22JysEtaq6pKp2VtXOvXv3HnrlAAdgfAFGMLYA67Hm4FVVT07yniQ/3t1fSPLrSZ6Z5NwkDyT5xX2LrrB6f01D91Xdvb27t2/duvVQ6wY4IOMLMIKxBViPNQWvqjo+s9D1ru5+b5J094Pd/Vh3fyXJm/P46YR7kpwxt/rpSe7fuJIBAACWy1rualhJ3prkru7+pbn2U+cWe2mS26fp65LsqKoTqurMJGcluWXjSgYAAFgua7mr4XOTvDLJn1bVbVPbTyV5RVWdm9lphLuT/EiSdPcdVXVtkjszuyPipe5oCAAAHMtWDV7d/eGsfN3WvznIOlckuWIddQEAABw1DumuhgAAABw6wQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGAwwQsAAGCwVYNXVZ1RVX9YVXdV1R1V9dqp/aSqurGqPjV9PXFuncuraldV3V1V54/sAAAAwKJbyxGvR5P8RHd/e5LnJLm0qs5OclmSm7r7rCQ3Tc8zzduR5JwkFyR5U1UdN6J4AACAZbBq8OruB7r7Y9P0F5PcleS0JBcluXpa7OokL5mmL0pyTXc/0t33JNmV5LwNrhsAAGBpHNI1XlW1LcmzknwkySnd/UAyC2dJnjYtdlqS++ZW2zO17b+tS6pqZ1Xt3Lt372GUDrAy4wswgrEFWI81B6+qenKS9yT58e7+wsEWXaGtv6ah+6ru3t7d27du3brWMgBWZXwBRjC2AOuxpuBVVcdnFrre1d3vnZofrKpTp/mnJnloat+T5Iy51U9Pcv/GlAsAALB81nJXw0ry1iR3dfcvzc26LsnF0/TFSd4/176jqk6oqjOTnJXklo0rGQAAYLlsWcMyz03yyiR/WlW3TW0/leTKJNdW1auS3Jvk5UnS3XdU1bVJ7szsjoiXdvdjG104AADAslg1eHX3h7PydVtJ8oIDrHNFkivWURcAAMBR45DuaggAAMChE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGE7wAAAAGWzV4VdXbquqhqrp9ru31VfXZqrpterxobt7lVbWrqu6uqvNHFQ4AALAs1nLE6x1JLlih/Ze7+9zp8W+SpKrOTrIjyTnTOm+qquM2qlgAAIBltGrw6u4PJfn8Grd3UZJruvuR7r4nya4k562jPgAAgKW3nmu8XlNVn5hORTxxajstyX1zy+yZ2gAAAI5Zhxu8fj3JM5Ocm+SBJL84tdcKy/ZKG6iqS6pqZ1Xt3Lt372GWAfC1jC/ACMYWYD0OK3h194Pd/Vh3fyXJm/P46YR7kpwxt+jpSe4/wDau6u7t3b1969ath1MGwIqML8AIxhZgPQ4reFXVqXNPX5pk3x0Pr0uyo6pOqKozk5yV5Jb1lQgAALDctqy2QFX9VpLnJTm5qvYkeV2S51XVuZmdRrg7yY8kSXffUVXXJrkzyaNJLu3ux4ZUDgAAsCRWDV7d/YoVmt96kOWvSHLFeooCAAA4mqznroYAAACsgeAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAwmOAFAAAw2JbNLgCAY9u2y24Ytu3dV144bNsAcCgc8QIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhM8AIAABhs1eBVVW+rqoeq6va5tpOq6saq+tT09cS5eZdX1a6quruqzh9VOAAAwLJYyxGvdyS5YL+2y5Lc1N1nJblpep6qOjvJjiTnTOu8qaqO27BqAQAAltCqwau7P5Tk8/s1X5Tk6mn66iQvmWu/prsf6e57kuxKct7GlAoAALCcthzmeqd09wNJ0t0PVNXTpvbTkvzx3HJ7pravUVWXJLkkSZ7+9KcfZhkAX8v4svG2XXbDZpcAm87YAqzHRt9co1Zo65UW7O6runt7d2/funXrBpcBHMuML8AIxhZgPQ73iNeDVXXqdLTr1CQPTe17kpwxt9zpSe5fT4EAcLhGH6nbfeWFQ7cPwNHjcI94XZfk4mn64iTvn2vfUVUnVNWZSc5Kcsv6SgQAAFhuqx7xqqrfSvK8JCdX1Z4kr0tyZZJrq+pVSe5N8vIk6e47quraJHcmeTTJpd392KDaAQAAlsKqwau7X3GAWS84wPJXJLliPUUBAHD0G3k6sFOBWTQbfXMNAAAA9iN4AQAADCZ4AQAADCZ4AQAADCZ4AQAADCZ4AQAADCZ4AQAADCZ4AQAADCZ4AQAADCZ4AQAADCZ4AQAADCZ4AQAADCZ4AQAADCZ4AQAADLZlswsAgGW17bIbhm1795UXDts2AEeeI14AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDbdnsAgAAWEzbLrths0uAo4YjXgAAAIMJXgAAAIM51RAAgKPO6NMkd1954dDtc/RxxAsAAGAwR7z249MRAABgozniBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMJjgBQAAMNiW9axcVbuTfDHJY0ke7e7tVXVSkt9Osi3J7iT/sLv/cn1lAgAALK+NOOL197v73O7ePj2/LMlN3X1Wkpum5wAAAMesEacaXpTk6mn66iQvGfAaAAAAS2O9wauTfKCqbq2qS6a2U7r7gSSZvj5tpRWr6pKq2llVO/fu3bvOMgAeZ3wBRjC2AOux3uD13O5+dpLvTXJpVX3XWlfs7qu6e3t3b9+6des6ywB4nPEFGMHYAqzHuoJXd98/fX0oyfuSnJfkwao6NUmmrw+tt0gAAIBldtjBq6qeVFVP2Ted5HuS3J7kuiQXT4tdnOT96y0SAABgma3ndvKnJHlfVe3bzru7+/er6qNJrq2qVyW5N8nL118mAADA8jrs4NXdn0nyd1do/1ySF6ynKAA41m277Iah29995YVDtw/AVxtxO3kAAADmCF4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDCV4AAACDbdnsAgBYv22X3bDZJQAAB+GIFwAAwGCCFwAAwGBONQQAgEM08hTv3VdeOGzbbB5HvAAAAAYTvAAAAAYTvAAAAAYTvAAAAAYTvAAAAAYTvAAAAAYTvAAAAAYTvAAAAAYTvAAAAAYTvAAAAAYTvAAAAAYTvAAAAAYTvAAAAAYTvAAAAAYTvAAAAAbbstkFAABw+LZddsNmlwCsgSNeAAAAgwleAAAAgwleAAAAgwleAAAAgwleAAAAg7mr4RE28s5Du6+8cNi2AQCAw+eIFwAAwGCCFwAAwGCCFwAAwGCu8QKAY5BrjgGOLMELAGCgkSEXWB6CF8AR4o8vADh2ucYLAABgMMELAABgMMELAABgMNd4HUVGXz/iLlUAAHB4BC8AAFggPkw/OjnVEAAAYDBHvAAmbvcOG8On9QBfa1jwqqoLkvxKkuOSvKW7rxz1WhwZy/xHqV/SAADLbdk/1BlyqmFVHZfk15J8b5Kzk7yiqs4e8VoAAACLbtQRr/OS7OruzyRJVV2T5KIkdw56PThqLeuRRkcZAQAeV9298RutelmSC7r71dPzVyb5zu5+zdwylyS5ZHr6bUnuPoSXODnJX2xQuYviaOvT0daf5Ojr06L15xndvXUjNrTO8WV/i/Y+rYWaj4xlq3nZ6k02puYjNbYs2vu7SPUsUi2JelazSPUsUi3J19ZzSOPLqOD18iTn7xe8zuvuH92g7e/s7u0bsa1FcbT16WjrT3L09elo688oy/g+qfnIWLaal63eZLlqXrRaF6meRaolUc9qFqmeRaolWX89o24nvyfJGXPPT09y/6DXAgAAWGijgtdHk5xVVWdW1dcn2ZHkukGvBQAAsNCG3Fyjux+tqtck+beZ3U7+bd19xwa+xFUbuK1FcbT16WjrT3L09elo688oy/g+qfnIWLaal63eZLlqXrRaF6meRaolUc9qFqmeRaolWWc9Q67xAgAA4HGjTjUEAABgIngBAAAMtlTBq6ouqKq7q2pXVV222fWsVVWdUVV/WFV3VdUdVfXaqf2kqrqxqj41fT1xbp3Lp37eXVXnb171B1ZVx1XVn1TV9dPzZe/PU6vqX1fVJ6fv1d9b5j5V1f8y/bzdXlW/VVVPWOb+jFZVPz997z9RVe+rqqfOzVvxvamq/6qq/nSa939VVR3hml8+fY+/UlXb95u3kDXvb1HH9ap6W1U9VFW3z7Ut9P6zbL9rpjHplqr6+FTvGxa53rkaFmqsWPRxYDP28UXafxdtv1zE/a4W6O/Jqto97Ru3VdXODa+nu5fikdlNOj6d5FuSfH2Sjyc5e7PrWmPtpyZ59jT9lCR/luTsJP88yWVT+2VJfm6aPnvq3wlJzpz6fdxm92OFfv2vSd6d5Prp+bL35+okr56mvz7JU5e1T0lOS3JPkidOz69N8kPL2p8j9J59T5It0/TPreW9SXJLkr+XpJL8XpLvPcI1f3tm/8T15iTb59oXtub96l/YcT3JdyV5dpLb59oWev/Jkv2umX4GnzxNH5/kI0mes6j1ztW9UGPFIo8Dm7WPL9L+u2j75SLud1mgvyeT7E5y8n5tG1bPMh3xOi/Jru7+THd/Ock1SS7a5JrWpLsf6O6PTdNfTHJXZn8YX5TZH/uZvr5kmr4oyTXd/Uh335NkV2b9XxhVdXqSC5O8Za55mfvzjZkN1G9Nku7+cnc/nCXuU2Z3LX1iVW1J8g2Z/S+9Ze7PUN39ge5+dHr6x5n9/8HkAO9NVZ2a5Bu7+496NgL/Rh5/P49UzXd1990rzFrYmvezsON6d38oyef3a17o/WfZftf0zJemp8dPj17UevdZtLFiwceBTdnHF2n/XbT9ctH2uyX5e3LD6lmm4HVakvvmnu+Z2pZKVW1L8qzMPmE4pbsfSGY7ZpKnTYstQ1/fmOQnk3xlrm2Z+/MtSfYmeft0uPstVfWkLGmfuvuzSX4hyb1JHkjyH7v7A1nS/myCH87sU+DkwO/NadP0/u2LYFlqXrafu6XZf5bld810itFtSR5KcmN3L3S9K1jksWIR6lmk79mm/1wtyn65YPvdG7NYf092kg9U1a1VdclG1zPk/3gNstL5x0t1L/yqenKS9yT58e7+wkFOqV7ovlbVi5M81N23VtXz1rLKCm0L05/JlsxOS/jR7v5IVf1KZoeTD2Sh+zSdf3xRZoe+H07yr6rqBw+2ygptC9OfjVJVH0zyt1aY9dPd/f5pmZ9O8miSd+1bbYXl+yDtG2otNa+02gptR6zmQ7Bo9RyuherHMv2u6e7Hkpw7XSf1vqr6joMsfsTqXbSxYonHgU3/GVuDIzWWL8x+uSj73YL+Pfnc7r6/qp6W5Maq+uRG1rNMwWtPkjPmnp+e2alTS6Gqjs9sh3tXd793an6wqk7t7gemQ/8PTe2L3tfnJvn+qnpRkick+caqemeWtz/JrMY906c+SfKvMwtey9qnFya5p7v3JklVvTfJf5Pl7c+G6O4XHmx+VV2c5MVJXjCdgpMc+L3Zk8dPMZpv31Cr1XwAm1rzIVi2n7uF33+W9XdNdz9cVTcnuSALUO+ijRVLPA4szM9YNvHnalH3ywXY7xbu78nuvn/6+lBVvS+zUwc3rJ5lOtXwo0nOqqozq+rrk+xIct0m17QmNftY461J7uruX5qbdV2Si6fpi5O8f659R1WdUFVnJjkrswthF0J3X97dp3f3tsy+D3/Q3T+YJe1PknT3nye5r6q+bWp6QZI7s7x9ujfJc6rqG6afvxdkdl75svZnuKq6IMn/nuT7u/s/zc1a8b2ZTjf4YlU9Z3qP/3Eefz8327LUvGzj+kLvP8v2u6aqtk6fuKeqnpjZB0afXNR691misWIR6lmkfXxTfq4Wbb9cpP1u0f6erKonVdVT9k1ndiOd2ze0nh54V5mNfiR5UWZ3g/l0ZofXN72mNdb932Z26PETSW6bHi9K8k1JbkryqenrSXPr/PTUz7uziXcdW0PfnpfH70Kz1P1Jcm6SndP36XeSnLjMfUryhswG09uT/GZmd91Z2v4cgfdrV2bnau/bR//Fau9Nku3T+/vpJL+apI5wzS/N7BO3R5I8mOTfLnrNK/RhIcf1JL+V2fWR/9/0Hr9q0fefZftdk+S/TPInU723J/mZqX0h652rYaHGikUfBzZjH1+k/XfR9stF3e+yAH9PZna9/8enxx37fl43sp6aVgIAAGCQZTrVEAAAYCkJXgAAAIMJXgAAAIMJXgAAAIMJXgAAAIMJXgAAAIMJXgAAAIP9/+0bK61dPU9IAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -1268,7 +1317,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1280,7 +1329,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAI4CAYAAAB3HEhGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAqAklEQVR4nO3de7hlZ10n+O+vUyEoF5NIgSFJU6DRMaE10NURGx4nimNCggafmXTHse3YgxPnEWztptuuyNjA2JmOthd67FEHBa0WJKQRIRJsCdGoeEksMMRciJQQSZFMUoBc24km+c0fexXZqZyqOpf31NmnzufzPPs5e797rbV/79pnvWd/97qc6u4AAACwdn9nowsAAAA4VghYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYbIiq+u6qeu9hnv/Nqrp0qWmr6nNV9ayjUScwlm3/0arq1VX1xqM9LxwLjCePZjxZHALWMaCq7qqqv54Gi/uq6peq6okbXddadPeLunv3IZ57Ynd/OEmq6per6t+t5jWm9XXg9vDcOvxcVX3nWuqHo8G2v7ptf5r/BVX1h1X16ar6ZFX9QVX9g9Uub9FU1blV1VX1toPav3Zqv2GuravqK456kSwU44nx5FCm8WTf3OPHVdXbpn4+uaourar3VdVnqmpfVf14VW3byJo3moB17PjW7n5ikucm+QdJ/veVzFwzW+r3YRpcnzitt49mWofT7U0HptvqgwQLz7a/QlX15CTvTPIzSU5OcmqS1yR5YCPrWgf7k/zDqvrSubZLk/z5BtXD4jOerNAWGk+SJFV1QpK3JTkxybd092eSfHGSH0zylCRfl+SFSf7VBpW4ELbURrAVdPfHkvxmkmcnSVU9b/pW5VNV9YGqOvfAtFV1Q1VdUVV/kOS/JXnW9E3m91XVh6rqs1X1o1X15VX1R9M3E1dX1ePmlvHiqrp5Wv4fVtXXzD23q6r+YlrO7VX17QeVW1X1M9M3Ph+sqhceVNv3LNXHA9+2VtVlSb4zyQ9N37j9RlX966r6tYOm/5mqeu1y1+GBb2qq6t9U1f+b5JdqicMQ5r/1raoTquonquqj0zd/P19VX7Tc14S1su2vaNv/ymmdvbm7H+ruv+7ud3f3LdN8X15Vv11Vn6iqj1fVm6rqxLnl3jW93i1V9fmqen1VPa1mhyN9tqreU1UnTdPumOq+rKruqap7q+oVh3ofj/C+PbOqfnd6jesy+zBzOH+T5O1JLpnmPy7JP0rypsPMA8YT48mhlvfFSX4jyfFJLuzuz099/7nu/v3u/pvpd+dNSZ5/pOUd07rbbZPfktyV5Jun+6cnuS3Jj2b2LconklyQWZj+H6bH26dpb8hsz81ZSbZltsF0kmuSPHlqfyDJ9UmeleRLktye5NJp/ucmuT+zbyuOy+yb0buSnDA9f3GSp0+v/Y+TfD7JKdNz353kwST/Ynrdf5zk00lOnqvte+amfe9cfzvJV0z3fznJv5t77pTpdU6cHm+bavz7K1iH5061/ViSE5J80cE1LFHHa6f1dnKSJ2U2AP37jf7dcDu2b7b91W37Ux8/kWR3khclOemg579iWmcnJNme5PeSvPag9f7HSZ42rev7k7w/yXOmeX47yaumaXdMdb85yROS/L3M9iwdeN9eneSN0/0jvW9/lOSnptf4hiSfPTDvEn08N8m+JP8wyY1T2wVJfivJ9yS5Yan16rZ1bzGeGE8OP57sT/K70/t6whF+l96e5MqN/p3eyJs9WMeOt1fVp5K8N7MN4P9M8k+SvKu739XdD3f3dUn2ZLaxHfDL3X1bdz/Y3X87tf1Yd3+mu29LcmuSd3f3h7v705l9o/Wcabr/Ncn/09039uxbm92ZDaLPS5Lu/i/dfc/02m9J8qEk58y99v2ZDTJ/Oz1/Z5IL17ISuvvezAavi6em85N8vLvft8JFPZzZgPZAd//14SasqspsXfyL7v5kd382s/V/yQpfE1bDtp+Vbfs9O6TlBZl9UPmFJPur6pqqetr0/N7uvm7a/vdn9iHkvz9oMT/T3ff17Nva388sxPxpdz+Q5NfzyLo64DXd/fnu/rMkv5TkO5boxiHft6r6u5kdsvUjU12/l9kXOUdaL3+Y5OSq+qok/zTJfz7SPGxpxpMYTw7hSUm+Psnuqa4lVdU/S7IzyU8cYXnHNAHr2PGS7j6xu5/R3d83hYJnJLl42jX8qWnQfEFm38wccPcSy7pv7v5fL/H4wEmvz0jyioOWf3pm3zSlqv7p3C7/T2V2qMH8LuiPdc++6pj85YF512h3ZgNLpp+/sopl7O/u/2+Z027P7Pjj98319b9O7bDebPuPWPa23913dPd3d/dpU31Pz2xPdKrqqVV1VVV9rKo+k+SNeezhM8tdVwfMr+9D9fdw79vTk/xVT4fkzC1nOX4lycuTfGNmH9bgUIwnjzCePNrHM/vieHdVnbfUBFX1kiRXJnlRd3/8CMs7pglYx7a7k/zKNFgeuD2hu6+cm6YPNfMyl3/FQcv/4u5+c1U9I7Nvcl6e5Eu7+8TMvsGquflPnfb+HPB3k9yzwhqWqv/tSb6mqp6d5MVZ3fkGBy/385mFqCRJVX3Z3HMfz2wAPGtuPXxJz04Uho1g21/Btt/dH8zsEKFnT03/flr+13T3kzP7cFVLz71sp8/dP1R/D/e+3ZvkpKp6wkHLWY5fSfJ9mX2b/d9WUzxbmvHEeJIk6e63ZbbH8a1V9Y3zz1XV+Zm9V9867Vnb0gSsY9sbk3xrVZ1XVcdV1eNrdgGH0wYt/xeS/G9V9XU184SqurCqnpTZscGd2TG7B3YZP/ug+Z+a5J9X1fFVdXGSr07yrhXWcF9mx3R/wbTn6a1JfjXJTd390ZV2bAkfSHJWVZ1dVY/P7DjnA6/3cGbr4qer6qlJUlWnHuobHjgKbPuH2far6r+rqlccWB9VdXpmh9j88TTJk5J8LsmnqurUJP96hbUt5Ueq6our6qwk/yzJW5aY5pDvW3f/ZWaH97ymZpdIfkGSb13OC3f3RzI7JOmVA/rB1mM8MZ58QXe/ObPA+46qen6SVNU3ZRZA/8fuvmlA/zY9AesY1t13J7koyQ9nNjjdndmGPeR97+49mX2T8Z+S/FWSvZmdRJruvj3JT2Z2EuV9mZ2I+QcHLeLGJGdktgfoiiT/U3d/YoVlvD7JmdPu77fPte+eXnM1hwc+Rnf/eZL/I8l7Mjv+++B/bPhvMuv/H0+HALwnyVeNeG1YKdv+Ebf9z2Z2Qv2NVfX5zD4I3ZrkwNW4XpPZifefTnJtZpckXqvfzWw9XZ/kJ7r73QdPsIz37X+e6v5kkldlBedTdfd7u3ul3+qD8cR48hg9O0/uFUmurapzkvxIZhcveVc98v9Ef3OVfTsm1KMPW4VjQ81O4Pxgki/r2QmowBawaNt+Ve1I8pEkx3f3gxtcDrACxhNWyx4sjjk1+yeH/zLJVYswIAJHh20fGMV4wlps2+gCYKTphM37MrsazvkbXA5wlNj2gVGMJ6yVQwQBAAAGcYggAADAIAtxiOBTnvKU3rFjx0aXASyY973vfR/v7hX/w2ZjCrAUYwow0qHGlIUIWDt27MiePXs2ugxgwVTVkf6z/JKMKcBSjCnASIcaUxwiCAAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMIiABQAAMMi2jS5gNXbsunZdl3/XlReu6/IBAIBjkz1YAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgyw7YFXVcVX1p1X1zunxyVV1XVV9aPp50ty0l1fV3qq6s6rOW4/CAQAAFs1K9mD9QJI75h7vSnJ9d5+R5PrpcarqzCSXJDkryflJfraqjhtTLgAAwOJaVsCqqtOSXJjkF+eaL0qye7q/O8lL5tqv6u4HuvsjSfYmOWdItQAAAAtsuXuwXpvkh5I8PNf2tO6+N0mmn0+d2k9NcvfcdPumtkepqsuqak9V7dm/f/9K6wZ4FGMKMJIxBVitIwasqnpxkvu7+33LXGYt0daPaeh+XXfv7O6d27dvX+aiAZZmTAFGMqYAq7VtGdM8P8m3VdUFSR6f5MlV9cYk91XVKd19b1WdkuT+afp9SU6fm/+0JPeMLBoAAGARHXEPVndf3t2ndfeOzC5e8dvd/U+SXJPk0mmyS5O8Y7p/TZJLquqEqnpmkjOS3DS8cgAAgAWznD1Yh3Jlkqur6qVJPprk4iTp7tuq6uoktyd5MMnLuvuhNVcKAACw4FYUsLr7hiQ3TPc/keSFh5juiiRXrLE2AACATWUl/wcLAACAwxCwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABjliwKqqx1fVTVX1gaq6rapeM7W/uqo+VlU3T7cL5ua5vKr2VtWdVXXeenYAAABgUWxbxjQPJPmm7v5cVR2f5L1V9ZvTcz/d3T8xP3FVnZnkkiRnJXl6kvdU1Vd290MjCwcAAFg0R9yD1TOfmx4eP936MLNclOSq7n6guz+SZG+Sc9ZcKQAAwIJb1jlYVXVcVd2c5P4k13X3jdNTL6+qW6rqDVV10tR2apK752bfN7UdvMzLqmpPVe3Zv3//6nsAEGMKMJYxBVitZQWs7n6ou89OclqSc6rq2Ul+LsmXJzk7yb1JfnKavJZaxBLLfF137+zundu3b19F6QCPMKYAIxlTgNVa0VUEu/tTSW5Icn533zcFr4eT/EIeOQxwX5LT52Y7Lck9ay8VAABgsS3nKoLbq+rE6f4XJfnmJB+sqlPmJvv2JLdO969JcklVnVBVz0xyRpKbhlYNAACwgJZzFcFTkuyuquMyC2RXd/c7q+pXqurszA7/uyvJ9yZJd99WVVcnuT3Jg0le5gqCAADAVnDEgNXdtyR5zhLt33WYea5IcsXaSgMAANhcVnQOFgAAAIcmYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAwiYAEAAAxyxIBVVY+vqpuq6gNVdVtVvWZqP7mqrquqD00/T5qb5/Kq2ltVd1bVeevZAQAAgEWxnD1YDyT5pu7+2iRnJzm/qp6XZFeS67v7jCTXT49TVWcmuSTJWUnOT/KzVXXcOtQOAACwUI4YsHrmc9PD46dbJ7koye6pfXeSl0z3L0pyVXc/0N0fSbI3yTkjiwYAAFhEyzoHq6qOq6qbk9yf5LruvjHJ07r73iSZfj51mvzUJHfPzb5vajt4mZdV1Z6q2rN///41dAHAmAKMZUwBVmtZAau7H+rus5OcluScqnr2YSavpRaxxDJf1907u3vn9u3bl1UswKEYU4CRjCnAaq3oKoLd/akkN2R2btV9VXVKkkw/758m25fk9LnZTktyz1oLBQAAWHTLuYrg9qo6cbr/RUm+OckHk1yT5NJpskuTvGO6f02SS6rqhKp6ZpIzktw0uG4AAICFs20Z05ySZPd0JcC/k+Tq7n5nVf1Rkqur6qVJPprk4iTp7tuq6uoktyd5MMnLuvuh9SkfAABgcRwxYHX3LUmes0T7J5K88BDzXJHkijVXBwAAsIms6BwsAAAADk3AAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGOSIAauqTq+q36mqO6rqtqr6gan91VX1saq6ebpdMDfP5VW1t6rurKrz1rMDAAAAi2LbMqZ5MMkruvv9VfWkJO+rquum5366u39ifuKqOjPJJUnOSvL0JO+pqq/s7odGFg4AALBojrgHq7vv7e73T/c/m+SOJKceZpaLklzV3Q9090eS7E1yzohiAQAAFtmKzsGqqh1JnpPkxqnp5VV1S1W9oapOmtpOTXL33Gz7cvhABgAAcExYdsCqqicm+bUkP9jdn0nyc0m+PMnZSe5N8pMHJl1i9l5ieZdV1Z6q2rN///6V1g3wKMYUYCRjCrBaywpYVXV8ZuHqTd39tiTp7vu6+6HufjjJL+SRwwD3JTl9bvbTktxz8DK7+3XdvbO7d27fvn0tfQAwpgBDGVOA1VrOVQQryeuT3NHdPzXXfsrcZN+e5Nbp/jVJLqmqE6rqmUnOSHLTuJIBAAAW03KuIvj8JN+V5M+q6uap7YeTfEdVnZ3Z4X93JfneJOnu26rq6iS3Z3YFwpe5giAAALAVHDFgdfd7s/R5Ve86zDxXJLliDXUBAABsOiu6iiAAAACHJmABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAMsm2jCwAAgBF27Lp2XZd/15UXruvyOTbYgwUAADCIgAUAADCIgAUAADCIgAUAADCIgAUAADCIgAUAADCIgAUAADCIgAUAADCIgAUAADCIgAUAADCIgAUAADCIgAUAADCIgAUAADCIgAUAADCIgAUAADDIEQNWVZ1eVb9TVXdU1W1V9QNT+8lVdV1VfWj6edLcPJdX1d6qurOqzlvPDgAAACyK5ezBejDJK7r7q5M8L8nLqurMJLuSXN/dZyS5fnqc6blLkpyV5PwkP1tVx61H8QAAAIvkiAGru+/t7vdP9z+b5I4kpya5KMnuabLdSV4y3b8oyVXd/UB3fyTJ3iTnDK4bAABg4azoHKyq2pHkOUluTPK07r43mYWwJE+dJjs1yd1zs+2b2g5e1mVVtaeq9uzfv38VpQM8wpgCjGRMAVZr2QGrqp6Y5NeS/GB3f+Zwky7R1o9p6H5dd+/s7p3bt29fbhkASzKmACMZU4DVWlbAqqrjMwtXb+rut03N91XVKdPzpyS5f2rfl+T0udlPS3LPmHIBAAAW13KuIlhJXp/kju7+qbmnrkly6XT/0iTvmGu/pKpOqKpnJjkjyU3jSgYAAFhM25YxzfOTfFeSP6uqm6e2H05yZZKrq+qlST6a5OIk6e7bqurqJLdndgXCl3X3Q6MLBwAAWDRHDFjd/d4sfV5VkrzwEPNckeSKNdQFAACw6azoKoIAAAAcmoAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwiIAFAAAwyBEDVlW9oarur6pb59peXVUfq6qbp9sFc89dXlV7q+rOqjpvvQoHAABYNMvZg/XLSc5fov2nu/vs6fauJKmqM5NckuSsaZ6frarjRhULAACwyI4YsLr795J8cpnLuyjJVd39QHd/JMneJOesoT4AAIBNYy3nYL28qm6ZDiE8aWo7Ncndc9Psm9oAAACOeasNWD+X5MuTnJ3k3iQ/ObXXEtP2Uguoqsuqak9V7dm/f/8qywCYMaYAIxlTgNVaVcDq7vu6+6HufjjJL+SRwwD3JTl9btLTktxziGW8rrt3dvfO7du3r6YMgC8wpgAjGVOA1VpVwKqqU+YefnuSA1cYvCbJJVV1QlU9M8kZSW5aW4kAAACbw7YjTVBVb05ybpKnVNW+JK9Kcm5VnZ3Z4X93JfneJOnu26rq6iS3J3kwycu6+6F1qRwAAGDBHDFgdfd3LNH8+sNMf0WSK9ZSFAAAwGa0lqsIAgAAMEfAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGETAAgAAGGTbRhcAAACbwY5d167r8u+68sJ1XT5Hhz1YAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAgwhYAAAAg2zb6AIA2Np27Lp23ZZ915UXrtuyAWAp9mABAAAMImABAAAMImABAAAMImABAAAMImABAAAMImABAAAM4jLtAByz1vMS8InLwAPwWPZgAQAADCJgAQAADCJgAQAADCJgAQAADCJgAQAADCJgAQAADCJgAQAADCJgAQAADCJgAQAADHLEgFVVb6iq+6vq1rm2k6vquqr60PTzpLnnLq+qvVV1Z1Wdt16FAwAALJrl7MH65STnH9S2K8n13X1Gkuunx6mqM5NckuSsaZ6frarjhlULAACwwI4YsLr795J88qDmi5Lsnu7vTvKSufaruvuB7v5Ikr1JzhlTKgAAwGJb7TlYT+vue5Nk+vnUqf3UJHfPTbdvanuMqrqsqvZU1Z79+/evsgyAGWMKMJIxBVit0Re5qCXaeqkJu/t13b2zu3du3759cBnAVmNMAUYypgCrtdqAdV9VnZIk08/7p/Z9SU6fm+60JPesvjwAAIDNY7UB65okl073L03yjrn2S6rqhKp6ZpIzkty0thIBAAA2h21HmqCq3pzk3CRPqap9SV6V5MokV1fVS5N8NMnFSdLdt1XV1UluT/Jgkpd190PrVDsAAMBCOWLA6u7vOMRTLzzE9FckuWItRQEAAGxGoy9yAQAAsGUJWAAAAIMIWAAAAIMIWAAAAIMIWAAAAIMIWAAAAIMIWAAAAIMc8f9gAQBL27Hr2nVd/l1XXriuywdgPHuwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABhGwAAAABtm20QUAsNh27Lp2o0sAgE3DHiwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBtm10AQDA0nbsunZdl3/XlReu6/IBtiJ7sAAAAAYRsAAAAAYRsAAAAAZxDhYAACwA510eG+zBAgAAGGRNe7Cq6q4kn03yUJIHu3tnVZ2c5C1JdiS5K8k/6u6/WluZAAAAi2/EHqxv7O6zu3vn9HhXkuu7+4wk10+PAQAAjnnrcYjgRUl2T/d3J3nJOrwGAADAwllrwOok766q91XVZVPb07r73iSZfj51qRmr6rKq2lNVe/bv37/GMoCtzpgCjGRMAVZrrQHr+d393CQvSvKyqvqG5c7Y3a/r7p3dvXP79u1rLAPY6owpwEjGFGC11hSwuvue6ef9SX49yTlJ7quqU5Jk+nn/WosEAADYDFYdsKrqCVX1pAP3k3xLkluTXJPk0mmyS5O8Y61FAgAAbAZruUz705L8elUdWM6vdvd/rao/SXJ1Vb00yUeTXLz2MgEAABbfqgNWd384ydcu0f6JJC9cS1EAAACb0Xpcph0AAGBLWsshggAAsCI7dl270SXAurIHCwAAYBABCwAAYBABCwAAYBABCwAAYBABCwAAYBBXEVzCel/d5q4rL1zX5QMAABvDHiwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBtm10AQCszY5d1250CQDAxB4sAACAQezBAgCALWC9j3i468oL13X5m4U9WAAAAIMIWAAAAIMIWAAAAIM4B2sDOP4VAACOTfZgAQAADGIPFgBsUY6oABjPHiwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBBCwAAIBBtm10AQAALI4du67d6BJgUxOwAACANVvvcH7XlReu6/JHcYggAADAIAIWAADAIA4RPAbZPQsAABtDwAJYZ04YB4CtwyGCAAAAg9iDBQCsC4esA1uRPVgAAACD2IPFivlGEgCAo22zfAYVsNhSNsuGCQDA5iRgsXBccW3jCKAAi8/fSVhs6xawqur8JP8xyXFJfrG7r1yv1wJYCx9WAIBR1uUiF1V1XJL/O8mLkpyZ5Duq6sz1eC0AAIBFsV57sM5Jsre7P5wkVXVVkouS3L5OrwcLwZ4QAPwtgK1tvQLWqUnunnu8L8nXzU9QVZcluWx6+LmqunMFy39Kko+vqcLNTf+3bv83dd/rx1Y8yzOWveyVjSmLuB7VtDyLWFOymHUd8zUt0JiyXIv4noygX5vLsdivIX0aNaZUd6+1lscutOriJOd19/dMj78ryTnd/f2Dlr+nu3eOWNZmpP9bt/9bue8jLeJ6VNPyLGJNyWLWpabFc6z2X782l2OxX4vWp/X6R8P7kpw+9/i0JPes02sBAAAshPUKWH+S5IyqemZVPS7JJUmuWafXAgAAWAjrcg5Wdz9YVS9P8luZXab9Dd1928CXeN3AZW1G+r91beW+j7SI61FNy7OINSWLWZeaFs+x2n/92lyOxX4tVJ/W5RwsAACArWi9DhEEAADYcgQsAACAQTZdwKqq86vqzqraW1W7NrqeEarq9Kr6naq6o6puq6ofmNpPrqrrqupD08+T5ua5fFoHd1bVeXPtf7+q/mx67v+qqtqIPq1UVR1XVX9aVe+cHm+lvp9YVW+tqg9OvwNfv5X6P1pV/WhV3VJVN1fVu6vq6XPPrWjdVdUJVfWWqf3Gqtqxypr+w/T+3lJVv15VJy5ATRdP483DVbXzoOc2pKZl1HzUxv+qekNV3V9Vt861beh2WQv4t6KqHl9VN1XVB6aaXrPRNW20qvpXVdVV9ZS5toXcppZjEcev9XY0x5oRFnFsGKU26+fD7t40t8wumPEXSZ6V5HFJPpDkzI2ua0C/Tkny3On+k5L8eZIzk/x4kl1T+64kPzbdP3Pq+wlJnjmtk+Om525K8vVJKslvJnnRRvdvmevgXyb51STvnB5vpb7vTvI90/3HJTlxK/V/Hdbnk+fu//MkP7/adZfk++bmvyTJW1ZZ07ck2Tbd/7G1vJ8Da/rqJF+V5IYkO+faN6ymI9R7VMf/JN+Q5LlJbp1r29DtMgv4t2Ka/4nT/eOT3JjkeRu9rjbqltm/qPmtJH+Z5Cmr7fPR2KZW0KeFG7/Wub+b7rPmIo4NA/u2KT8fbrY9WOck2dvdH+7uv0lyVZKLNrimNevue7v7/dP9zya5I8mpmfVt9zTZ7iQvme5flOSq7n6guz+SZG+Sc6rqlMw+XP5Rz36j/vPcPAurqk5LcmGSX5xr3ip9f3JmH+RenyTd/Tfd/alskf6vh+7+zNzDJyQ5cCWf1ay7+ffhrUleuJpvvrr73d394PTwjzP734AbXdMd3X3nEk9tWE1HcFTH/+7+vSSfPKh5Q7fLRfxb0TOfmx4eP916I2vaYD+d5IfyyLiTLO42tSyLOH6ts033WXMRx4YRNvPnw80WsE5Ncvfc431T2zFj2l3+nMy+BXxad9+bzDaeJE+dJjvUejh1un9w+6J7bWZ/kB6ea9sqfX9Wkv1JfmnaBf6LVfWEbJ3+r4uquqKq7k7ynUn+7dS8mnX3hXmmDxifTvKlayzvf8nsG7RFqmneItZ0uLqOpoXZLhfpb8V0CM/NSe5Pcl13b3hNG6Gqvi3Jx7r7Awc9tajb1Gos+vg1wiKMNau2SGPDAK/NJv18uC7/B2sdLfUtRy/RtilV1ROT/FqSH+zuzxzmS51DrYdNt36q6sVJ7u/u91XVucuZZYm2Tdn3ybbMDkP6/u6+sar+Y2a7vA/lWOv/qlTVe5J82RJPvbK739Hdr0zyyqq6PMnLk7wqq1t3y16vR6ppmuaVSR5M8qYjLP+o1bTUbOtZ0xos8u/4Ud0uF+1vRXc/lOTs6dycX6+qZx9m8k09hh1um0ryw5kdTveY2ZZoW4Rt6gsWcfzaQJuhxiUt2tiwFpv98+FmC1j7Mju++YDTktyzQbUMVVXHZ7ZRvKm73zY131dVp3T3vdMuzvun9kOth315ZNf9fPsie36Sb6uqC5I8PsmTq+qN2Rp9T2Z175u+8U1mh0zsytbp/6p09zcvc9JfTXJtZgFrNevuwDz7qmpbki/JYw8bW1ZNVXVpkhcneeF0mML88jekpkNY15rWYBHG/w3fLhf5b0V3f6qqbkhy/qLUNNqhtqmq+nuZnffxgelD7WlJ3l9V52Rxt6kvWMTxawMtwlizYos8NqzS5v582Atwct5yb5kFwg9nNogdOPHwrI2ua0C/KrNjQl97UPt/yKNP5Pvx6f5ZefSJfB/OIyfy/UlmJxgfOJHvgo3u3wrWw7l55CTGLdP3JL+f5Kum+6+e+r5l+r8O6/OMufvfn+Stq113SV6WR5+QffUqazo/ye1Jth/UvmE1zdVwQx59kYsNr+kQdR718T/Jjjz6Ihcbul1mAf9WJNme5MTp/hdlNp69eKPX1UbfktyVRy5ysZDb1Ar6srDj1zr1d9N91lzEsWFw/87NJvt8uOG/FKtYyRdkdnWUv8hs1/WG1zSgTy/IbHflLUlunm4XZHZc8vVJPjT9PHlunldO6+DOzF0NJcnOJLdOz/2nJLXR/VvBepjfgLZM35OcnWTP9P6/PclJW6n/67A+f21aD7ck+Y0kp6523WX2rdl/yexk2ZuSPGuVNe3N7NjwA9v3zy9ATd+e2Td7DyS5L8lvbXRNy6j5qI3/Sd6c5N4kfzutp5du9HaZBfxbkeRrkvzpVNOtSf7t1L6lx7DMBazV9PlobVPL7MvCjV9Hoc+b6rPmIo4Ng/t3bjbZ58MDv/AAAACs0Wa7iiAAAMDCErAAAAAGEbAAAAAGEbAAAAAGEbAAAAAGEbAAAAAGEbAAAAAG+f8B/HLZ63jhFZAAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1292,7 +1341,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1308,12 +1357,12 @@ " fig, ax = plt.subplots(1,3, figsize=(12,8), sharey=True)\n", " if hack[column].dtype.name in ['float64']:\n", " ax[0].hist(hack[column].values)\n", - " ax[1].hist(predictions_mi[column].values)\n", - " ax[2].hist(predictions_k2[column].values)\n", + " ax[1].hist(synth_data_mi[column].values)\n", + " ax[2].hist(synth_data_k2[column].values)\n", " else:\n", " ax[0].barh(hack[column].value_counts().index, hack[column].value_counts().values)\n", - " ax[1].barh(predictions_mi[column].value_counts().index, predictions_mi[column].value_counts().values)\n", - " ax[2].barh(predictions_k2[column].value_counts().index, predictions_k2[column].value_counts().values)\n", + " ax[1].barh(synth_data_mi[column].value_counts().index, synth_data_mi[column].value_counts().values)\n", + " ax[2].barh(synth_data_k2[column].value_counts().index, synth_data_k2[column].value_counts().values)\n", " ax[0].set_title(f'{column} True')\n", " ax[1].set_title(f'{column} Sampled MI')\n", " ax[2].set_title(f\"{column} Sampled K2\")\n", @@ -1321,13 +1370,748 @@ " plt.tight_layout()" ] }, + { + "cell_type": "markdown", + "id": "8d071604", + "metadata": {}, + "source": [ + "___\n", + "## Predict() function" + ] + }, + { + "cell_type": "markdown", + "id": "ecb7d94d", + "metadata": {}, + "source": [ + "#### Preparartions" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "7ee20b01", + "metadata": {}, + "outputs": [], + "source": [ + "d = p.info\n", + "\n", + "bn_1 = Nets.HybridBN()\n", + "bn_1.add_nodes(d)" + ] + }, { "cell_type": "code", - "execution_count": null, - "id": "4e66d1da", + "execution_count": 30, + "id": "396a3883", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "bn_2 = Nets.HybridBN()\n", + "bn_2.add_nodes(d)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "2a6664a4", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84e1edd456a54c1f829780d9221f2c02", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000000 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
namenode_typedata_typeparentsparents_types
0Tectonic regimeDiscretedisc[][]
1PeriodConditionalLogit (LogisticRegression)disc[Depth, Structural setting, Lithology][cont, disc, disc]
2LithologyConditionalLogit (LogisticRegression)disc[Netpay, Structural setting][cont, disc]
3Structural settingLogit (LogisticRegression)disc[Permeability][cont]
4GrossGaussiancont[Porosity][cont]
5NetpayGaussiancont[Permeability][cont]
6PorosityConditionalGaussiancont[Tectonic regime][disc]
7PermeabilityGaussiancont[Gross][cont]
8DepthGaussiancont[Gross][cont]
\n", + "" + ], + "text/plain": [ + " name node_type data_type \\\n", + "0 Tectonic regime Discrete disc \n", + "1 Period ConditionalLogit (LogisticRegression) disc \n", + "2 Lithology ConditionalLogit (LogisticRegression) disc \n", + "3 Structural setting Logit (LogisticRegression) disc \n", + "4 Gross Gaussian cont \n", + "5 Netpay Gaussian cont \n", + "6 Porosity ConditionalGaussian cont \n", + "7 Permeability Gaussian cont \n", + "8 Depth Gaussian cont \n", + "\n", + " parents parents_types \n", + "0 [] [] \n", + "1 [Depth, Structural setting, Lithology] [cont, disc, disc] \n", + "2 [Netpay, Structural setting] [cont, disc] \n", + "3 [Permeability] [cont] \n", + "4 [Porosity] [cont] \n", + "5 [Permeability] [cont] \n", + "6 [Tectonic regime] [disc] \n", + "7 [Gross] [cont] \n", + "8 [Gross] [cont] " + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bn_1.get_info(as_df=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "9fc5987c", + "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", + "
namenode_typedata_typeparentsparents_types
0Tectonic regimeDiscretedisc[][]
1PeriodDiscretedisc[Structural setting][disc]
2LithologyDiscretedisc[][]
3Structural settingDiscretedisc[Tectonic regime][disc]
4GrossConditionalGaussiancont[Period, Lithology, Structural setting][disc, disc, disc]
5NetpayGaussiancont[Gross][cont]
6PorosityConditionalGaussiancont[Period][disc]
7PermeabilityConditionalGaussiancont[Porosity, Lithology][cont, disc]
8DepthConditionalGaussiancont[Porosity, Structural setting][cont, disc]
\n", + "
" + ], + "text/plain": [ + " name node_type data_type \\\n", + "0 Tectonic regime Discrete disc \n", + "1 Period Discrete disc \n", + "2 Lithology Discrete disc \n", + "3 Structural setting Discrete disc \n", + "4 Gross ConditionalGaussian cont \n", + "5 Netpay Gaussian cont \n", + "6 Porosity ConditionalGaussian cont \n", + "7 Permeability ConditionalGaussian cont \n", + "8 Depth ConditionalGaussian cont \n", + "\n", + " parents parents_types \n", + "0 [] [] \n", + "1 [Structural setting] [disc] \n", + "2 [] [] \n", + "3 [Tectonic regime] [disc] \n", + "4 [Period, Lithology, Structural setting] [disc, disc, disc] \n", + "5 [Gross] [cont] \n", + "6 [Period] [disc] \n", + "7 [Porosity, Lithology] [cont, disc] \n", + "8 [Porosity, Structural setting] [cont, disc] " + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bn_2.get_info(as_df=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "838b8a23", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wall time: 7.8 s\n" + ] + } + ], + "source": [ + "%%time\n", + "bn_1.fit_parameters(hack)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "17a60d82", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wall time: 9.51 s\n" + ] + } + ], + "source": [ + "%%time\n", + "bn_2.fit_parameters(hack)" + ] + }, + { + "cell_type": "markdown", + "id": "e213843f", + "metadata": {}, + "source": [ + "User can use bn.predict() to get predictions according to train data. Note that predict is async function so user can set a number of threads. It is more accurate due to dealing with signs but it can take a long time.
\n", + "Performance time can increase because of:\n", + "1. Logit Nodes with big models\n", + "2. Mixture Nodes\n", + "3. Problems with serialization (Joblib is slower than Pickle) \n", + "

\n", + "For more details, check TimeComparison.ipynb.\n", + "**Since each continuous node trains a distribution, sample value can be negative while a train variable itself doesn't.**
\n", + "Predict requires a test dataset, train dataset without testing columns (nodes)." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "2143cceb", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Tectonic regimePeriodLithologyStructural settingGrossNetpayPorosityPermeabilityDepth
0COMPRESSIONJURASSICLIMESTONEFORELAND75.055.221.0410.01815.0
1EXTENSIONCRETACEOUSSANDSTONERIFT223.543.210.08.03084.6
2STRIKE-SLIPNEOGENETHINLY-BEDDED SANDSTONEWRENCH34.519.822.0200.02952.9
3STRIKE-SLIPNEOGENESANDSTONEWRENCH152.7123.020.0300.03149.7
4COMPRESSIONCRETACEOUSLIMESTONESALT75.030.021.060.01486.5
..............................
507EXTENSIONPALEOGENESANDSTONERIFT69.020.726.71872.01615.2
509EXTENSIONPALEOGENESANDSTONERIFT49.218.623.2121.01416.3
511EXTENSIONMESOZOICVOLCANICSRIFT147.658.212.73.62952.9
512COMPRESSIONCARBONIFEROUSSANDSTONEFORELAND78.69.924.030.0561.0
513COMPRESSIONCARBONIFEROUSSANDSTONEFORELAND38.413.226.01000.0967.5
\n", + "

442 rows × 9 columns

\n", + "
" + ], + "text/plain": [ + " Tectonic regime Period Lithology \\\n", + "0 COMPRESSION JURASSIC LIMESTONE \n", + "1 EXTENSION CRETACEOUS SANDSTONE \n", + "2 STRIKE-SLIP NEOGENE THINLY-BEDDED SANDSTONE \n", + "3 STRIKE-SLIP NEOGENE SANDSTONE \n", + "4 COMPRESSION CRETACEOUS LIMESTONE \n", + ".. ... ... ... \n", + "507 EXTENSION PALEOGENE SANDSTONE \n", + "509 EXTENSION PALEOGENE SANDSTONE \n", + "511 EXTENSION MESOZOIC VOLCANICS \n", + "512 COMPRESSION CARBONIFEROUS SANDSTONE \n", + "513 COMPRESSION CARBONIFEROUS SANDSTONE \n", + "\n", + " Structural setting Gross Netpay Porosity Permeability Depth \n", + "0 FORELAND 75.0 55.2 21.0 410.0 1815.0 \n", + "1 RIFT 223.5 43.2 10.0 8.0 3084.6 \n", + "2 WRENCH 34.5 19.8 22.0 200.0 2952.9 \n", + "3 WRENCH 152.7 123.0 20.0 300.0 3149.7 \n", + "4 SALT 75.0 30.0 21.0 60.0 1486.5 \n", + ".. ... ... ... ... ... ... \n", + "507 RIFT 69.0 20.7 26.7 1872.0 1615.2 \n", + "509 RIFT 49.2 18.6 23.2 121.0 1416.3 \n", + "511 RIFT 147.6 58.2 12.7 3.6 2952.9 \n", + "512 FORELAND 78.6 9.9 24.0 30.0 561.0 \n", + "513 FORELAND 38.4 13.2 26.0 1000.0 967.5 \n", + "\n", + "[442 rows x 9 columns]" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hack_filtered = hack.dropna()\n", + "hack_filtered" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "2300a61b", + "metadata": {}, + "outputs": [], + "source": [ + "columns = ['Lithology', 'Structural setting', 'Porosity', 'Depth']\n", + "validY = hack_filtered[columns]\n", + "validX = hack_filtered.drop(columns, axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "80204403", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 442/442 [25:14<00:00, 3.43s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wall time: 25min 45s\n" + ] + } + ], + "source": [ + "%%time\n", + "predictions_mi = bn_1.predict(test=validX, parall_count=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "a4848808", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 442/442 [06:11<00:00, 1.19it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wall time: 6min 15s\n" + ] + } + ], + "source": [ + "%%time\n", + "predictions_k2 = bn_2.predict(test=validX, parall_count=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "e0bfea50", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lithology Accuracy: 0.5610859729\n", + "Structural setting Accuracy: 0.0180995475\n", + "Porosity MSE: 7.5495339634\n", + "Depth MSE: 1074.3471603141\n" + ] + } + ], + "source": [ + "# Bn_1 Metrics\n", + "for column in columns:\n", + " if bn_1.descriptor['types'][column] == 'cont':\n", + " print(f\"{column: <25} MSE: {round(mean_squared_error(validY[column], predictions_mi[column], squared=False), 10): >13}\")\n", + " else:\n", + " print(f\"{column: <25} Accuracy: {round(accuracy_score(validY[column], predictions_mi[column]), 10)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "9aa5e165", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lithology Accuracy: 0.5610859729\n", + "Structural setting Accuracy: 0.2760180995\n", + "Porosity MSE: 7.5496374869\n", + "Depth MSE: 1076.1643805127\n" + ] + } + ], + "source": [ + "# Bn_1 Metrics\n", + "for column in columns:\n", + " if bn_2.descriptor['types'][column] == 'cont':\n", + " print(f\"{column: <25} MSE: {round(mean_squared_error(validY[column], predictions_k2[column], squared=False), 10): >13}\")\n", + " else:\n", + " print(f\"{column: <25} Accuracy: {round(accuracy_score(validY[column], predictions_k2[column]), 10)}\")" + ] } ], "metadata": {