diff --git a/README.md b/README.md
index 9f4ff2b..6cc6e15 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,69 @@
-# pyQSARplus
-Library of tools for the analysis of QSAR/QSPR datasets and models.
+# qsarify
-# What is included?
------------------
+qsarify is a library of tools for the analysis of QSAR/QSPR datasets and models. This library is intended to be used to produce models which relate a set of calculated chemical descriptors to a given numeric endpoint. Many great tools will take the geometry or string data of a given chemical and compute **descriptors**, which are numeric measures of the properties of these, but you can generate some of these with another one of my scripts, [Free Descriptors](https://github.com/StephenSzwiec/free_descriptors).
-- Data preprocessing: `data_tools`
+# Dependencies
+
+- Python 3
+- [numpy](https://numpy.org/)
+- [pandas](https://pandas.pydata.org/)
+- [scikit-learn](https://scikit-learn.org)
+- [matplotlib](https://matplotlib.org)
+
+
+# Installation
+
+`pip install qsarify`
+
+# What is included right now?
+
+- Data preprocessing tools: `data_tools`
- Dimensionality reduction via clustering: `clustering`
+- Feature selection:
+ - Single threaded: `feature_selection_single`
+ - Multi-threaded: `feature_selection_multi`
+- Model Export and Visualization: `model_export`
+- Cross Valiidation: `cross_validation`
+
+# How to use
+
+The best way to learn how to use this library is to look at the example notebook in the `examples` folder. This notebook will walk you through the workflow of using this library to build a QSAR model.
+
+# Future Plans
+
+- Massively parallel feature selection methods:
+ - CUDA acceleration
+ - MPI acceleration
+- Include Shannon Entropy as a dimensionality reduction metric in clustering
+- Embedded kernel methods
+- More visualization tools
+- More cross validation tools
+- Feature selection tools for categorical data
+
+# Contributing
+
+
+If you would like to contribute to this project, please feel free to fork this repository and submit a pull request. Otherwise, you may also submit an issue. I will try to respond to issues as quickly as possible.
+
+# License
+
+
+This project is licensed under the GNU GPLv3 license. See the LICENSE file for more details.
+
+# Citation
+
+If you use this library in your work, please cite it as follows:
+
+Szwiec, Stephen. (2023). qsarify: A high performance library for QSAR model development.
+
+BibTex:
+```
+@misc{szwiec2023qsarify,
+ author = {Szwiec, Stephen},
+ title = {qsarify: A high performance library for QSAR model development},
+ year = {2023},
+ publisher = {GitHub},
+ journal = {GitHub repository},
+ howpublished = {\url{https://github.com/stephenszwiec/qsarify}},
+ }
+```
diff --git a/Untitled.ipynb b/Untitled.ipynb
deleted file mode 100644
index 4ba45b3..0000000
--- a/Untitled.ipynb
+++ /dev/null
@@ -1,1780 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 1,
- "id": "2a56c28f-2cc5-4baa-b30b-4e85453affcb",
- "metadata": {
- "tags": []
- },
- "outputs": [],
- "source": [
- "# basic toolkit for the workflow\n",
- "import pandas as pd\n",
- "import data_tools as dt\n",
- "import clustering as cl\n",
- "import feature_selection_single as fss\n",
- "import feature_selection_multi as fsm\n",
- "import cross_validation as cv\n",
- "import export_model as em"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "id": "70cd653c-efdc-405b-989a-a50d40f5b9a5",
- "metadata": {
- "tags": []
- },
- "outputs": [],
- "source": [
- "# in this example, the last column is the response variable (log10 of LD50)\n",
- "# we use pandas to manipulate the data\n",
- "dfx = pd.DataFrame(pd.read_csv('28BenzeneDescriptors.csv')).iloc[:,:-1]\n",
- "dfy = pd.DataFrame(pd.read_csv('28BenzeneDescriptors.csv')).iloc[:,-1]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "id": "9992350f-1431-49d3-9f57-1cef849eb4cc",
- "metadata": {
- "tags": []
- },
- "outputs": [
- {
- "data": {
- "text/html": [
- "
+#-*- coding: utf-8 -*-
+# Author: Stephen Szwiec
+# Date: 2023-02-19
+# Description: Classification Scoring Module
+#
+#Copyright (C) 2023 Stephen Szwiec
+#
+#This file is part of qsarify.
+#
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Classification Scoring Module
+
+This module provides summary information about Classification
+"""
+
+importnumpyasnp
+fromsklearn.metricsimportaccuracy_score
+
+
+[docs]
+classClassifierScore:
+"""
+ Provides summary information about Classification
+
+ Parameters
+ ----------
+ y_data : pandas DataFrame , shape = (n_samples,)
+ pred_y : pandas DataFrame , shape = (n_samples,)
+ => predicted Y values as result of classification
+
+ Sub functions
+ -------
+ score (self)
+ tf_table(self)
+ """
+
+ def__init__(self,y_data,pred_y):
+"""
+ Initializes the classifer
+ """
+ # Initialize the variables
+ self.y_data=y_data
+ self.pred_y=pred_y
+ self.real_y=[]#hash y_data
+ # Hash the y_data
+ foriinnp.array(self.y_data):
+ self.real_y.append(i[0])
+
+
+[docs]
+ defscore(self):
+"""
+ Calculate accuracy score
+ Returns
+ -------
+ None
+ """
+ # Initialize the variables
+ n=0
+ cnt=0
+ # Count the number of wrong predictions
+ foriinnp.array(self.real_y):
+ ifi!=self.pred_y[n]:
+ cnt+=1
+ n+=1
+ print('Number of all :',n)#all data
+ print('Number of worng :',cnt)
+ print('AccuracyScore :',accuracy_score(self.real_y,self.pred_y))
+
+
+
+[docs]
+ deftf_table(self):
+"""
+ Calculate Precision & Recall
+ Generates a confusion matrix
+
+ Returns
+ -------
+ None
+ """
+ # Initialize the variables
+ one=0
+ zero=0
+ n=0
+ cnt=0
+ realzero=0
+ realone=0
+ # Initialize the confusion matrix
+ foriinnp.array(self.y_data):
+ ifi[0]==0:
+ zero+=1
+ ifi[0]==1:
+ one+=1
+ # Count the number of wrong predictions
+ foriinnp.array(self.y_data):
+ ifi[0]!=self.pred_y[n]:
+ #print ('real',i[0],'///','pred',y_pred[n])
+ ifi[0]==0:
+ realzero+=1
+ ifi[0]==1:
+ realone+=1
+ cnt+=1
+ n+=1
+ # Print the results
+ print(('Number of 1 :',one))
+ print('Number of 0 :',zero)
+ print('True Positive(real 1 but pred 1) :',one-realone)#TP
+ print('True Negative(real 0 but pred 0) :',zero-realzero)#TN
+ print('False Positive(real 0 but pred 1) :',realzero)#FP
+ print('False Negative(real 1 but pred 0) :',realone)#FN
+ print('Precision',(one-realone)/((one-realone)+realzero))# TP / TP+FP
+ print('Recall',(one-realone)/((one-realone)+realone))# TP / TP+FN
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/html/man/html/_modules/qsarify/clustering.html b/docs/html/man/html/_modules/qsarify/clustering.html
new file mode 100644
index 0000000..0376f2f
--- /dev/null
+++ b/docs/html/man/html/_modules/qsarify/clustering.html
@@ -0,0 +1,280 @@
+
+
+
+
+
+ qsarify.clustering — qsarify 0.1 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#-*- coding: utf-8 -*-
+# Author: Stephen Szwiec
+# Date: 2023-02-19
+# Description: Clustering Module
+#
+#Copyright (C) 2023 Stephen Szwiec
+#
+#This file is part of qsarify.
+#
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+#
+
+"""
+Clustering Module
+
+This module contains functions for clustering features based on hierarchical clustering method
+and calculating the cophenetic correlation coefficient of linkages. The cophenetic correlation
+coefficient is a measure of the correlation between the distance of observations in feature space
+and the distance of observations in cluster space. The cophenetic correlation coefficient is
+calculated for each linkage method and the method with the highest cophenetic correlation
+coefficient is used to cluster the features. The cophenetic correlation coefficient is calculated
+using the scipy.cluster.hierarchy.cophenet function.
+
+"""
+
+importnumpyasnp
+importpandasaspd
+frompandasimportDataFrame,Series
+importmatplotlib.pyplotasplt
+fromscipy.spatial.distanceimportpdist,squareform
+fromscipy.cluster.hierarchyimportlinkage,dendrogram,fcluster,cophenet
+
+
+[docs]
+defcophenetic(X_data):
+"""
+ Calculate the cophenetic correlation coefficient of linkages
+
+ Parameters
+ ----------
+ X_data : pandas DataFrame, shape = (n_samples, m_features)
+ method : str, method for linkage generation, default = 'corr' (Pearson correlation)
+
+ Returns
+ -------
+ None
+ """
+ distance=abs(np.corrcoef(X_data,rowvar=False))
+ # drop any columns and rows that produced NaNs
+ distance=distance[~np.isnan(distance).any(axis=1)]
+ distance=distance[:,~np.isnan(distance).any(axis=0)]
+ # calculate the cophenetic correlation coefficient
+ Z1=linkage(distance,method='average',metric='euclidean')
+ Z2=linkage(distance,method='complete',metric='euclidean')
+ Z3=linkage(distance,method='single',metric='euclidean')
+ c1,coph_dists1=cophenet(Z1,pdist(distance))
+ c2,coph_dists2=cophenet(Z2,pdist(distance))
+ c3,coph_dists3=cophenet(Z3,pdist(distance))
+ print("cophenetic correlation average linkage: ",c1)
+ print("cophenetic correlation complete linkage: ",c2)
+ print("cophenetic correlation single linkage: ",c3)
+
+
+
+[docs]
+classfeatureCluster:
+"""
+ Make cluster of features based on hierarchical clustering method
+
+ Parameters
+ ----------
+ X_data : pandas DataFrame, shape = (n_samples, n_features)
+ link : str, kind of linkage method, default = 'average', 'complete', 'single'
+ cut_d : int, depth in cluster(dendrogram), default = 3
+
+ Sub functions
+ -------------
+ set_cluster(self)
+ cluster_dist(self)
+ """
+
+ def__init__(self,X_data,method='corr',link='average',cut_d=3):
+"""
+ Initializes cluster object:
+ Makes a cluster of features based on hierarchical clustering method
+ and calculates the cophenetic correlation coefficient of linkages
+
+ Parameters
+ ----------
+ X_data : pandas DataFrame, shape = (n_samples, n_features)
+ link : str, kind of linkage method, default = 'average', 'complete', 'single'
+ cut_d : int, depth in cluster(dendrogram), default = 3
+ This is a tunable parameter for clustering
+ """
+ self.method=method
+ self.cluster_info=[]
+ self.assignments=np.array([])
+ self.cluster_output=DataFrame()
+ self.cludict={}
+ self.X_data=X_data
+ self.link=link
+ self.cut_d=cut_d
+ self.xcorr=pd.DataFrame(abs(np.corrcoef(self.X_data,rowvar=False)),columns=X_data.columns,index=X_data.columns)
+
+
+[docs]
+ defset_cluster(self,verbose=False,graph=False):
+"""
+ Make cluster of features based on hierarchical clustering method
+
+ Parameters
+ ----------
+ verbose : bool, print cluster information, default = False
+ graph : bool, show dendrogram, default = False
+
+ Returns
+ -------
+ cludict : dict, cluster information of features as a dictionary
+ """
+ Z=linkage(self.xcorr,method=self.link,metric='euclidean')
+ self.assignments=fcluster(Z,self.cut_d,criterion='distance')
+ self.cluster_output=DataFrame({'Feature':list(self.X_data.columns.values),'cluster':self.assignments})
+ nc=list(self.cluster_output.cluster.values)
+ name=list(self.cluster_output.Feature.values)
+ # zip cluster number and feature name
+ self.cludict=dict(zip(name,nc))
+ # make cluster information as an input for feature selection function
+ # print cluster information for key in cludict.items if range of cluster number is 1~nnc
+ fortinrange(1,max(nc)+1):
+ self.cluster_info.append([kfork,vinself.cludict.items()ifv==t])
+ ifverbose:
+ print('\n','\x1b[1;46m'+'Cluster'+'\x1b[0m',t,self.cluster_info[t-1],)
+ ifgraph:
+ plt.figure(figsize=(25,40))
+ plt.title('Hierarchical Clustering Dendrogram')
+ plt.xlabel('sample index')
+ plt.ylabel('distance')
+ dendrogram(Z,color_threshold=self.cut_d,above_threshold_color='k',no_labels=True,leaf_label_func=None,show_contracted=True,orientation='left')
+ plt.show()
+ returnself.cludict
+
+
+
+[docs]
+ defcluster_dist(self):
+"""
+ Show dendrogram of hierarchical clustering
+
+ Returns
+ -------
+ None
+ """
+
+ # have we actually clustered? If not, please do so first:
+ ifself.assignments.any()==False:
+ self.set_cluster()
+ nc=list(self.cluster_output.cluster.values)
+ cluster=[[kfork,valueinself.cludict.items()ifvalue==t]fortinrange(1,max(nc)+1)]
+ # list comprehension which returns a list of average autocorrelation values for each cluster, unless the cluster length is 1
+ # in which case it returns nothing
+ dist_box=[(np.array([self.xcorr.loc[i,i]]).sum()-len(i)/2)/(len(i)**2-len(i)/2)foriinclusteriflen(i)>1]
+ plt.hist(dist_box)
+ plt.ylabel("Frequency")
+ ifself.method=='info':
+ plt.xlabel("Shannon mutual information of each cluster")
+ else:
+ plt.xlabel("Correlation coefficient of each cluster")
+ plt.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/html/man/html/_modules/qsarify/data_tools.html b/docs/html/man/html/_modules/qsarify/data_tools.html
new file mode 100644
index 0000000..df61e50
--- /dev/null
+++ b/docs/html/man/html/_modules/qsarify/data_tools.html
@@ -0,0 +1,357 @@
+
+
+
+
+
+ qsarify.data_tools — qsarify 0.1 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#-*- coding: utf-8 -*-
+# Author: Stephen Szwiec
+# Date: 2023-02-19
+# Description: Data Preprocessing Module
+#
+#Copyright (C) 2023 Stephen Szwiec
+#
+#This file is part of qsarify.
+#
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+#
+
+"""
+Data Preprocessing Module
+
+This module contains functions for data preprocessing, including:
+ - removing features with 'NaN' as value
+ - removing features with constant values
+ - removing features with low variance
+ - removing features with 'NaN' as value when calculating correlation coefficients
+ - generating a sequential train-test split by sorting the data by response variable
+ - generating a random train-test split
+ - scaling data
+
+The main function of this module is `clean_data`, which performs all of the above functions.
+
+"""
+
+
+
+importnumpyasnp
+fromnumpyimportndarray
+importpandasaspd
+frompandasimportDataFrame,Series
+importmatplotlib.pyplotasplt
+fromsklearn.preprocessingimportMinMaxScaler
+
+
+[docs]
+defrm_nan(X_data):
+"""
+ Remove features with 'NaN' as value
+
+ Parameters
+ ----------
+ X_data : pandas DataFrame , shape = (n_samples, n_features)
+
+ Returns
+ -------
+ Modified DataFrame
+ """
+ # get the indices of the features with 'NaN' as value
+ A=X_data.isnull().any()
+ # delete the features with 'NaN' as value
+ returnX_data.drop(X_data.columns[A],axis=1)
+#-*- coding: utf-8 -*-
+# Author: Stephen Szwiec
+# Date: 2023-02-19
+# Description: Multi-Processing Feature Selection Module
+#
+#Copyright (C) 2023 Stephen Szwiec
+#
+#This file is part of qsarify.
+#
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+
+"""
+Multi-Processing Feature Selection Module
+
+This module contains the functions for performing feature selection using
+the clustering module's output as a guide for feature selection, and implements
+a genetic algorithm for feature selection using reflection.
+
+"""
+
+importdatetime
+importrandom
+importnumpyasnp
+fromsklearnimportlinear_modelaslm
+fromsklearn.svmimportSVC
+importitertools
+importmultiprocessingasmp
+
+"""
+Reflector class for the evolve function; allows for the use of a pool of workers.
+"""
+
+[docs]
+classEvolution:
+"""
+ Initializes the evolution class with the learning algorithm to be used
+ """
+ def__init__(self,evolve):
+ self.e_mlr=lm.LinearRegression()
+ self.evolve=evolve
+
+"""
+ Function call for the evolution function
+ """
+ def__call__(self,i,cluster_info,cluster,X_data,y_data):
+ returnself.evolve(i,cluster_info,cluster,X_data,y_data,self.e_mlr)
+
+"""
+ Evolution of descriptors for learning algorithm, implemented as a function map
+
+ Parameters
+ ----------
+ i: list, descriptor set
+ cluster_info: dict, descriptor cluster information
+ cluster: list, descriptor cluster
+ X_data: DataFrame, descriptor data
+ y_data: DataFrame, target data
+ """
+
+[docs]
+ defevolve(i,cluster_info,cluster,X_data,y_data,e_mlr):
+ # Get the descriptors in the model
+ i=i[1]
+ # Get the groups of descriptors in model
+ group_n=[cluster_info[x]-1forxini]
+ # randomly select one descriptor to remove
+ sw_index=random.randrange(0,len(i))
+ # randomly select new group from cluster to swap with
+ sw_group=random.randrange(0,max(list(cluster_info.values())))
+ whilesw_groupingroup_n:
+ # make sure the new group is not in the current group
+ sw_group=random.randrange(0,len(cluster))
+ # list comprehension which generates a new list of descriptors by
+ # swapping the indexed descriptor with a new one randomly chosen from the new cluster group
+ b_set=[random.choice(cluster[sw_group])ifx==sw_indexelsei[x]forxinrange(0,len(i))]
+ b_set.sort()
+ x=X_data[b_set].values
+ y=y_data.values.ravel()
+ score=e_mlr.fit(x,y).score(x,y)
+ return[score,b_set]
+
+
+
+
+[docs]
+defselection(X_data,y_data,cluster_info,model="regression",learning=500000,bank=200,component=4,interval=1000,cores=(mp.cpu_count()*2)-1):
+"""
+ Forward feature selection using cophenetically correlated data on mutliple cores
+
+ Parameters
+ ----------
+ X_data : pandas DataFrame , shape = (n_samples, n_features)
+ y_data : pandas DataFrame , shape = (n_samples,)
+ cluster_info : dictionary returned by clustering.featureCluster.set_cluster()
+ model : default="regression", otherwise "classification"
+ learning : default=500000, number of overall models to be trained
+ bank : default=200, number of models to be trained in each iteration
+ component : default=4, number of features to be selected
+ interval : optional, default=1000, print current scoring and selected features
+ every interval
+ cores: optional, default=(mp.cpu_count()*2)-1, number of processes to be used
+ for multiprocessing; default is twice the number of cores minus 1, which
+ is assuming you have SMT, HT, or something similar) If you have a large
+ number of cores, you may want to set this to a lower number to avoid
+ memory issues.
+
+ Returns
+ -------
+ list, result of selected best feature set
+ """
+ now=datetime.datetime.now()
+ print("Start time: ",now.strftime('%H:%M:%S'))
+
+ ifmodel=="regression":
+ print('\x1b[1;42m','Regression','\x1b[0m')
+ y_mlr=lm.LinearRegression()
+ e_mlr=lm.LinearRegression()
+ else:
+ print('\x1b[1;42m','Classification','\x1b[0m')
+ y_mlr=SVC(kernel='rbf',C=1,gamma=0.1,random_state=0)
+ e_mlr=SVC(kernel='rbf',C=1,gamma=0.1,random_state=0)
+
+ # a list of numbered clusters
+ nc=list(cluster_info.values())
+ num_clusters=list(range(max(nc)))
+
+ # extract information from dictionary by inversion
+ inv_cluster_info=dict()
+ fork,vincluster_info.items():
+ inv_cluster_info.setdefault(v,list()).append(k)
+
+ # an ordered list of features in each cluster
+ cluster=list(dict(sorted(inv_cluster_info.items())).values())
+
+ # fill the interation bank with random models
+ # models contain (1 - component) number of features
+ # ensure the models are not duplicated and non redundant
+ index_sort_bank=set()
+ model_bank=[ini_descfor_inrange(bank)forini_descin[sorted([random.choice(cluster[random.choice(num_clusters)])for_inrange(random.randint(1,component))])]ifini_descnotintuple(index_sort_bank)andnotindex_sort_bank.add(tuple(ini_desc))]
+
+ # score each set of features, saving each score and the corresponding feature set
+ scoring_bank=list(map(lambdax:[y_mlr.fit(np.array(X_data.loc[:,x]),y_data.values.ravel()).score(np.array(X_data.loc[:,x]),y_data),list(X_data.loc[:,x].columns.values)],model_bank))
+
+ # create a reflection of the evolution function
+ evolver=Evolution(Evolution.evolve)
+
+ withmp.Pool(processes=cores)aspool:
+ # perform main learning loop
+ forninrange(learning):
+ # initialize best score to the worst possible score
+ best_score=-float("inf")
+ # Evolve the bank of models and allow those surpassing the best score to replace the worst models up to the bank size
+ results=pool.starmap(evolver,[(i,cluster_info,cluster,X_data,y_data)foriinscoring_bank])
+ rank_filter=[xforxinresultsif(best_score:=max(best_score,x[0]))==x[0]]
+ scoring_bank=sorted(itertools.chain(scoring_bank,rank_filter),reverse=True)[:bank]
+ ifn%interval==0andn!=0:
+ tt=datetime.datetime.now()
+ print(n,'=>',tt.strftime('%H:%M:%S'),scoring_bank[0])
+
+
+ # print output and return best model found during training
+ print("Best score: ",scoring_bank[0])
+ clulog=[cluster_info[y]for_,yinscoring_bank[0][1]]
+ print("Model's cluster info",clulog)
+ fi=datetime.datetime.now()
+ fiTime=fi.strftime('%H:%M:%S')
+ print("Finish Time : ",fiTime)
+ returnscoring_bank[0][1]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/html/man/html/_modules/qsarify/feature_selection_single.html b/docs/html/man/html/_modules/qsarify/feature_selection_single.html
new file mode 100644
index 0000000..befd596
--- /dev/null
+++ b/docs/html/man/html/_modules/qsarify/feature_selection_single.html
@@ -0,0 +1,332 @@
+
+
+
+
+
+ qsarify.feature_selection_single — qsarify 0.1 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#-*- coding: utf-8 -*-
+# Author: Stephen Szwiec
+# Date: 2023-02-19
+# Description: Single-Threaded Feature Selection Module
+#
+#Copyright (C) 2023 Stephen Szwiec
+#
+#This file is part of qsarify.
+#
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Single-Threaded Feature Selection Module
+
+This module contains the single-threaded version of the feature selection algorithm,
+which is a genetic algorithm that uses a linear regression model to score each set of features,
+using the output of clustering to ensure that the features are not redundant.
+
+"""
+importdatetime
+importrandom
+importnumpyasnp
+importpandasaspd
+importsklearn.linear_modelaslm
+importitertools
+
+
+[docs]
+defmlr_selection(X_data,y_data,cluster_info,component,model="regression",learning=50000,bank=200,interval=1000):
+"""
+ Performs feature selection using a using a linear regression model and a genetic algorithm on a single thread.
+ This is the vanilla version of the algorithm, which is not parallelized.
+
+ Parameters
+ ----------
+ X_data: DataFrame, descriptor data
+ y_data: DataFrame, target data
+ cluster_info: dict, descriptor cluster information
+ component: int, number of features to select
+ model: str, learning algorithm to use, default = "regression"
+ learning: int, number of iterations to perform, default = 50000
+ bank: int, number of models to keep in the bank, default = 200
+ interval: int, number of iterations to perform before printing the current time, default = 1000
+
+ Returns
+ -------
+ best_model: list, best model found
+ best_score: float, best score found
+ """
+
+ now=datetime.datetime.now()
+ print("Start time: ",now.strftime('%H:%M:%S'))
+
+ ifmodel=="regression":
+ print('\x1b[1;42m','Regression','\x1b[0m')
+ y_mlr=lm.LinearRegression()
+ e_mlr=lm.LinearRegression()
+ else:
+ print('\x1b[1;42m','Classification','\x1b[0m')
+ y_mlr=SVC(kernel='rbf',C=1,gamma=0.1,random_state=0)
+ e_mlr=SVC(kernel='rbf',C=1,gamma=0.1,random_state=0)
+
+ # a list of numbered clusters
+ nc=list(cluster_info.values())
+ num_clusters=list(range(max(nc)))
+
+ # extract information from dictionary by inversion
+ inv_cluster_info=dict()
+ fork,vincluster_info.items():
+ inv_cluster_info.setdefault(v,list()).append(k)
+
+ # an ordered list of features in each cluster
+ cluster=list(dict(sorted(inv_cluster_info.items())).values())
+
+ # fill the interation bank with random models
+ # models contain 1-component number of features
+ # ensure the models are not duplicated and non redundant
+ index_sort_bank=set()
+ model_bank=[ini_descfor_inrange(bank)forini_descin[sorted([random.choice(cluster[random.choice(num_clusters)])for_inrange(random.randint(1,component))])]ifini_descnotintuple(index_sort_bank)andnotindex_sort_bank.add(tuple(ini_desc))]
+
+ # score each set of features, saving each score and the corresponding feature set
+ scoring_bank=list(map(lambdax:[y_mlr.fit(np.array(X_data.loc[:,x]),y_data.values.ravel()).score(np.array(X_data.loc[:,x]),y_data),list(X_data.loc[:,x].columns.values)],model_bank))
+
+ defevolve(i):
+"""
+ Evolution of descriptors for learning algorithm, implemented as a function map
+
+ Parameters
+ ----------
+ i: list, descriptor set
+ """
+ i=i[1]
+ group_n=[cluster_info[x]-1forxini]
+ sw_index=random.randrange(0,len(i))
+ sw_group=random.randrange(0,max(nc))
+ whilesw_groupingroup_n:
+ sw_group=random.randrange(0,max(nc))
+ b_set=[random.choice(cluster[sw_group])ifx==sw_indexelsei[x]forxinrange(0,len(i))]
+ b_set.sort()
+ x=X_data[b_set].values
+ y=y_data.values.ravel()
+ score=e_mlr.fit(x,y).score(x,y)
+ return[score,b_set]
+
+ # perform main learning loop
+ forninrange(learning):
+ # initialize best score to the worst possible score
+ best_score=-float("inf")
+ # Evolve the bank of models and allow those surpassing the best score to replace the worst models up to the bank size
+ rank_filter=filter(lambdax,best_score=best_score:x[0]>best_scoreand(best_score:=x[0]),map(evolve,scoring_bank))
+ scoring_bank=sorted(itertools.chain(scoring_bank,rank_filter),reverse=True)[:bank]
+ ifn%interval==0andn!=0:
+ tt=datetime.datetime.now()
+ print(n,'=>',tt.strftime('%H:%M:%S'),scoring_bank[0])
+
+ # print output and return best model found during training
+ print("Best score: ",scoring_bank[0][0])
+ clulog=[cluster_info[y]foryinscoring_bank[0][1]]
+ print("Model's cluster info",clulog)
+ fi=datetime.datetime.now()
+ fiTime=fi.strftime('%H:%M:%S')
+ print("Finish Time : ",fiTime)
+ returnscoring_bank[0][1]
+
+
+
+[docs]
+defrf_selection(X_data,y_data,cluster_info,component,model="regression",learning=50000,bank=200,interval=1000):
+"""
+ Performs feature selection using a using a random forest model and a genetic algorithm on a single thread.
+ This is the vanilla version of the algorithm, which is not parallelized.
+
+ Parameters
+ ----------
+ X_data: DataFrame, descriptor data
+ y_data: DataFrame, target data
+ cluster_info: dict, descriptor cluster information
+ component: int, number of features to select
+ model: str, learning algorithm to use, default = "regression"
+ learning: int, number of iterations to perform, default = 50000
+ bank: int, number of models to keep in the bank, default = 200
+ interval: int, number of iterations to perform before printing the current time, default = 1000
+
+ Returns
+ -------
+ best_model: list, best model found
+ best_score: float, best score found
+ """
+
+ now=datetime.datetime.now()
+ print("Start time: ",now.strftime('%H:%M:%S'))
+
+ ifmodel=="regression":
+ print('\x1b[1;42m','Regression','\x1b[0m')
+ y_rf=RandomForestRegressor(n_estimators=100,max_depth=2,random_state=0)
+ e_rf=RandomForestRegressor(n_estimators=100,max_depth=2,random_state=0)
+ else:
+ print('\x1b[1;42m','Classification','\x1b[0m')
+ y_rf=RandomForestClassifier(n_estimators=100,max_depth=2,random_state=0)
+ e_rf=RandomForestClassifier(n_estimators=100,max_depth=2,random_state=0)
+
+ # a list of numbered clusters
+ nc=list(cluster_info.values())
+ num_clusters=list(range(max(nc)))
+
+ # extract information from dictionary by inversion
+ inv_cluster_info=dict()
+ fork,vincluster_info.items():
+ inv_cluster_info.setdefault(v,list()).append(k)
+
+ # an ordered list of features in each cluster
+ cluster=list(dict(sorted(inv_cluster_info.items())).values())
+
+ # fill the interation bank with random models
+ # models contain 1-component number of features
+ # ensure the models are not duplicated and non redundant
+ index_sort_bank=set()
+ model_bank=[ini_descfor_inrange(bank)forini_descin[sorted([random.choice(cluster[random.choice(num_clusters)])for_inrange(random.randint(1,component))])]ifini_descnotintuple(index_sort_bank)andnotindex_sort_bank.add(tuple(ini_desc))]
+
+ # score each set of features, saving each score and the corresponding feature set
+ scoring_bank=list(map(lambdax:[y_rf.fit(np.array(X_data.loc[:,x]),y_data.values.ravel()).score(np.array(X_data.loc[:,x]),y_data),list(X_data.loc[:,x].columns.values)],model_bank))
+
+ defevolve(i):
+"""
+ Evolution of descriptors for learning algorithm, implemented as a function map
+
+ Parameters
+ ----------
+ i: list, descriptor set
+ """
+ i=i[1]
+ group_n=[cluster_info[x]-1forxini]
+ sw_index=random.randrange(0,len(i))
+ sw_group=random.randrange(0,max(nc))
+ whilesw_groupingroup_n:
+ sw_group=random.randrange(0,max(nc))
+ b_set=[random.choice(cluster[sw_group])ifx==sw_indexelsei[x]forxinrange(0,len(i))]
+ b_set.sort()
+ x=X_data[b_set].values
+ y=y_data.values.ravel()
+ score=e_rf.fit(x,y).score(x,y)
+ return[score,b_set]
+
+ # perform main learning loop
+ forninrange(learning):
+ # initialize best score to the worst possible score
+ best_score=-float("inf")
+ # Evolve the bank of models and allow those surpassing the best score to replace the worst models up to the bank size
+ rank_filter=filter(lambdax,best_score=best_score:x[0]>best_scoreand(best_score:=x[0]),map(evolve,scoring_bank))
+ scoring_bank=sorted(itertools.chain(scoring_bank,rank_filter),reverse=True)[:bank]
+ ifn%interval==0andn!=0:
+ tt=datetime.datetime.now()
+ print(n,'=>',tt.strftime('%H:%M:%S'),scoring_bank[0])
+
+ # print output and return best model found during training
+ print("Best score: ",scoring_bank[0][0])
+ clulog=[cluster_info[y]foryinscoring_bank[0][1]]
+ print("Model's cluster info",clulog)
+ fi=datetime.datetime.now()
+ fiTime=fi.strftime('%H:%M:%S')
+ print("Finish Time : ",fiTime)
+ returnscoring_bank[0][1]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/html/man/html/_modules/qsarify/qsar_scoring.html b/docs/html/man/html/_modules/qsarify/qsar_scoring.html
new file mode 100644
index 0000000..186e8f7
--- /dev/null
+++ b/docs/html/man/html/_modules/qsarify/qsar_scoring.html
@@ -0,0 +1,232 @@
+
+
+
+
+
+ qsarify.qsar_scoring — qsarify 0.1 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# -*- coding: utf-8 -*-
+# Author: Stephen Szwiec
+# Date: 2023-02-19
+# Description: QSAR Scoring Module
+"""
+Copyright (C) 2023 Stephen Szwiec
+
+This file is part of qsarify.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+"""
+importnumpyasnp
+"""
+Commonly used scoring functions for QSAR models
+"""
+
+
+[docs]
+defq2f_score(y_true,y_pred,y_mean):
+"""
+ Calculates the Q2_f1 or Q2_f2 score
+ depending on whether the mean is calculated from the training set or the external set
+
+ Parameters
+ ----------
+ y_true : numpy array, shape (n_samples,)
+ y_pred : numpy array, shape (n_samples,)
+ y_mean : float, mean of the training (for q2f1) or test (for q2f2) set
+
+ Returns
+ -------
+ float
+ """
+ press=np.sum(np.square(y_true-y_pred))
+ tss=np.sum(np.square(y_true-y_mean))
+ return1-press/tss
+
+
+
+[docs]
+defq2f3_score(y_true,y_pred,n_train,n_external):
+"""
+ Calculates the Q2_f3 score
+
+ Parameters
+ ----------
+ y_true : numpy array, shape (n_samples,)
+ y_pred : numpy array, shape (n_samples,)
+ n_external : int
+ number of external samples
+ n_train : int
+ number of training samples
+
+ Returns
+ -------
+ float
+ """
+ press=np.sum(np.square(y_true-y_pred))
+ tss=np.sum(np.square(y_true-np.mean(y_true)))
+ return1-(press/n_external)/(tss*n_train)
This module contains functions for clustering features based on hierarchical clustering method
+and calculating the cophenetic correlation coefficient of linkages. The cophenetic correlation
+coefficient is a measure of the correlation between the distance of observations in feature space
+and the distance of observations in cluster space. The cophenetic correlation coefficient is
+calculated for each linkage method and the method with the highest cophenetic correlation
+coefficient is used to cluster the features. The cophenetic correlation coefficient is calculated
+using the scipy.cluster.hierarchy.cophenet function.
This module contains the functions for performing feature selection using
+the clustering module’s output as a guide for feature selection, and implements
+a genetic algorithm for feature selection using reflection.
cluster_info (dictionary returned by clustering.featureCluster.set_cluster()) –
+
model (default="regression", otherwise "classification") –
+
learning (default=500000, number of overall models to be trained) –
+
bank (default=200, number of models to be trained in each iteration) –
+
component (default=4, number of features to be selected) –
+
interval (optional, default=1000, print current scoring and selected features) – every interval
+
cores (optional, default=(mp.cpu_count()*2)-1, number of processes to be used) – for multiprocessing; default is twice the number of cores minus 1, which
+is assuming you have SMT, HT, or something similar) If you have a large
+number of cores, you may want to set this to a lower number to avoid
+memory issues.
+
+
+
Return type:
+
list, result of selected best feature set
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/html/man/html/man/qsarify.feature_selection_single.html b/docs/html/man/html/man/qsarify.feature_selection_single.html
new file mode 100644
index 0000000..d38d0db
--- /dev/null
+++ b/docs/html/man/html/man/qsarify.feature_selection_single.html
@@ -0,0 +1,168 @@
+
+
+
+
+
+
+ qsarify.feature_selection_single module — qsarify 0.1 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
This module contains the single-threaded version of the feature selection algorithm,
+which is a genetic algorithm that uses a linear regression model to score each set of features,
+using the output of clustering to ensure that the features are not redundant.
Performs feature selection using a using a linear regression model and a genetic algorithm on a single thread.
+This is the vanilla version of the algorithm, which is not parallelized.
Performs feature selection using a using a random forest model and a genetic algorithm on a single thread.
+This is the vanilla version of the algorithm, which is not parallelized.
This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
This module contains functions for clustering features based on hierarchical clustering method
+and calculating the cophenetic correlation coefficient of linkages. The cophenetic correlation
+coefficient is a measure of the correlation between the distance of observations in feature space
+and the distance of observations in cluster space. The cophenetic correlation coefficient is
+calculated for each linkage method and the method with the highest cophenetic correlation
+coefficient is used to cluster the features. The cophenetic correlation coefficient is calculated
+using the scipy.cluster.hierarchy.cophenet function.
This module contains the functions for performing feature selection using
+the clustering module’s output as a guide for feature selection, and implements
+a genetic algorithm for feature selection using reflection.
cluster_info (dictionary returned by clustering.featureCluster.set_cluster()) –
+
model (default="regression", otherwise "classification") –
+
learning (default=500000, number of overall models to be trained) –
+
bank (default=200, number of models to be trained in each iteration) –
+
component (default=4, number of features to be selected) –
+
interval (optional, default=1000, print current scoring and selected features) – every interval
+
cores (optional, default=(mp.cpu_count()*2)-1, number of processes to be used) – for multiprocessing; default is twice the number of cores minus 1, which
+is assuming you have SMT, HT, or something similar) If you have a large
+number of cores, you may want to set this to a lower number to avoid
+memory issues.
+
+
+
Return type:
+
list, result of selected best feature set
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/html/man/html/qsarify.feature_selection_single.html b/docs/html/man/html/qsarify.feature_selection_single.html
new file mode 100644
index 0000000..e423629
--- /dev/null
+++ b/docs/html/man/html/qsarify.feature_selection_single.html
@@ -0,0 +1,199 @@
+
+
+
+
+
+
+ qsarify.feature_selection_single module — qsarify 0.1 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
This module contains the single-threaded version of the feature selection algorithm,
+which is a genetic algorithm that uses a linear regression model to score each set of features,
+using the output of clustering to ensure that the features are not redundant.
Performs feature selection using a using a linear regression model and a genetic algorithm on a single thread.
+This is the vanilla version of the algorithm, which is not parallelized.
Performs feature selection using a using a random forest model and a genetic algorithm on a single thread.
+This is the vanilla version of the algorithm, which is not parallelized.
This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# perform 5-fold cross validation of the model\n",
+ "cross_validation.kfoldcv(k=5, verbose=True, show_plots=True)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.12.0"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/feature_selection_single.py b/feature_selection_single.py
deleted file mode 100644
index 8085e4a..0000000
--- a/feature_selection_single.py
+++ /dev/null
@@ -1,145 +0,0 @@
-#-*- coding: utf-8 -*-
-# Author: Stephen Szwiec
-# Date: 2023-02-19
-# Description: Single-Threaded Feature Selection Module
-"""
-Copyright (C) 2023 Stephen Szwiec
-
-This file is part of pyqsarplus.
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program. If not, see .
-
-"""
-import datetime
-import random
-import numpy as np
-import sklearn.linear_model as lm
-import itertools
-
-def mlr_selection(X_data, y_data, cluster_info, component, X_ext=None, y_ext=None, learning=50000, bank=200, interval=1000):
- """
- Performs feature selection using a using a linear regression model and a genetic algorithm on a single thread.
- This is the vanilla version of the algorithm, which is not parallelized.
-
- Parameters
- ----------
- X_data: DataFrame, descriptor data (training set)
- y_data: DataFrame, target data (training set)
- cluster_info: dict, descriptor cluster information
- component: int, number of features to select
- X_ext: DataFrame, descriptor data (test set)
- Y_ext: DataFrame, target data (test set)
- model: str, learning algorithm to use, default = "regression"
- learning: int, number of iterations to perform, default = 50000
- bank: int, number of models to keep in the bank, default = 200
- interval: int, number of iterations to perform before printing the current time, default = 1000
-
- Returns
- -------
- best_model: list, best model found
- best_score: float, best score found
- best_q2: float, score of best model found (not best q2)
- """
-
- now = datetime.datetime.now()
- print("Start time: ", now.strftime('%H:%M:%S'))
-
- if (X_ext is None and y_ext is None):
- is_ext = False
- elif (X_ext is not None and y_ext is not None):
- is_ext = True
- else:
- raise ValueError("X_ext and y_ext must both be None or both be DataFrames.")
- return None
-
- print('\x1b[1;42m','Regression','\x1b[0m')
- y_mlr = lm.LinearRegression()
-
- # a list of numbered clusters
- nc = list(cluster_info.values())
- num_clusters = list(range(max(nc)))
-
- # extract information from dictionary by inversion
- inv_cluster_info = dict()
- for k, v in cluster_info.items():
- inv_cluster_info.setdefault(v, list()).append(k)
-
- # an ordered list of features in each cluster
- cluster = list(dict(sorted(inv_cluster_info.items())).values())
-
- # fill the interation bank with random models
- # models contain 1-component number of features
- # ensure the models are not duplicated and non redundant
- index_sort_bank = set()
- model_bank = [ ini_desc for _ in range(bank) for ini_desc in [sorted([random.choice(cluster[random.choice(num_clusters)]) for _ in range(random.randint(1,component))])] if ini_desc not in tuple(index_sort_bank) and not index_sort_bank.add(tuple(ini_desc))]
-
- # score each set of features, saving each score and the corresponding feature set
- scoring_bank = list(map(lambda x: [y_mlr.fit(np.array(X_data.loc[:,x]), y_data.values.ravel()).score(np.array(X_data.loc[:,x]), y_data), list(X_data.loc[:,x].columns.values)], model_bank))
-
- # create external scoring bank if external data is provided
- if is_ext:
- scoring_bank_ext = list(map(lambda x: [y_mlr.fit(np.array(X_data.loc[:,x]), y_data.values.ravel()).score(np.array(X_ext.loc[:,x]), y_ext), list(X_ext.loc[:,x].columns.values)], model_bank))
-
- def evolve(i):
- """
- Evolution of descriptors for learning algorithm, implemented as a function map
-
- Parameters
- ----------
- i: list, descriptor set
- """
- i = i[1]
- group_n = [cluster_info[x]-1 for x in i]
- sw_index = random.randrange(0, len(i))
- sw_group = random.randrange(0, max(nc))
- while sw_group in group_n:
- sw_group = random.randrange(0, max(nc))
- b_set = [random.choice(cluster[sw_group]) if x == sw_index else i[x] for x in range(0, len(i))]
- b_set.sort()
- x = X_data[b_set].values
- y = y_data.values.ravel()
- score = y_mlr.fit(x, y).score(x, y)
- if is_ext:
- score_ext = y_mlr.fit(x, y).score(X_ext[b_set].values, y_ext)
- return [score, b_set, score_ext]
- else:
- return [score, b_set]
-
- # perform main learning loop
- for n in range(learning):
- # initialize best score to the worst possible score
- best_score = -float("inf")
- if is_ext:
- best_q2 = -float("inf")
- # Evolve the bank of models and allow those surpassing the best score to replace the worst models up to the bank size
- rank_filter = filter(lambda x, best_score=best_score: x[0] > best_score and (best_score := x[0]), map(evolve, scoring_bank))
- scoring_bank = sorted(itertools.chain(scoring_bank, rank_filter), reverse = True)[:bank]
- if is_ext:
- scoring_bank_ext = sorted(itertools.chain(scoring_bank_ext, rank_filter), reverse = True)[:bank]
- # print the current time every interval iterations
- if n % interval == 0 and n != 0:
- tt = datetime.datetime.now()
- if is_ext:
- print(n, '=>', tt.strftime('%H:%M:%S'), scoring_bank[0], scoring_bank_ext[0])
- else:
- print(n, '=>', tt.strftime('%H:%M:%S'), scoring_bank[0])
- # print output and return best model found during training
- print("Best score: ", scoring_bank[0][0])
- clulog = [cluster_info[y] for y in scoring_bank[0][1]]
- if is_ext:
- print("Best q2: ", scoring_bank_ext[0][0])
- print("Model's cluster info", clulog)
- fi = datetime.datetime.now()
- fiTime = fi.strftime('%H:%M:%S')
- print("Finish Time : ", fiTime)
diff --git a/kernel_methods.py b/kernel_methods.py
deleted file mode 100644
index 201c68c..0000000
--- a/kernel_methods.py
+++ /dev/null
@@ -1,169 +0,0 @@
-#-*- encoding utf-8 -*-
-# Author: Stephen Szwiec
-# Date: 2023-02-19
-# Description: Kernel Methods Module
-"""
-Copyright (C) 2023 Stephen Szwiec
-
-This file is part of pyqsarplus.
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program. If not, see .
-
-"""
-import numpy as np
-
-def epanechnikov(t):
- """
- Returns the Epanechnikov kernel function evaluated at t
-
- Parameters
- ----------
- t : numpy array, shape (n_samples,)
-
- Returns
- -------
- numpy array, shape (n_samples,)
-
- """
- return np.where(np.abs(t) <= 1, 0.75*(1-t**2), 0)
-
-def gaussian(t):
- """
- Returns the Gaussian kernel function evaluated at t
-
- Parameters
- ----------
- t : numpy array, shape (n_samples,)
-
- Returns
- -------
- numpy array, shape (n_samples,)
-
- """
- return (1/np.sqrt(2*np.pi))*np.exp(-0.5*t**2)
-
-def laplacian(t):
- """
- Returns the Laplacian kernel function evaluated at t
-
- Parameters
- ----------
- t : numpy array, shape (n_samples,)
-
- Returns
- -------
- numpy array, shape (n_samples,)
-
- """
- return np.where(np.abs(t) <= 1, 0.5*np.exp(-np.abs(t)), 0)
-
-def cosine(t):
- """
- Returns the Cosine kernel function evaluated at t
-
- Parameters
- ----------
- t : numpy array, shape (n_samples,)
-
- Returns
- -------
- numpy array, shape (n_samples,)
-
- """
- return np.where(np.abs(t) <= 1, np.pi/4*np.cos(np.pi*t/2), 0)
-
-def logistic(t):
- """
- Returns the Logistic kernel function evaluated at t
-
- Parameters
- ----------
- t : numpy array, shape (n_samples,)
-
- Returns
- -------
- numpy array, shape (n_samples,)
-
- """
- return 1/(np.exp(t) + 2 + np.exp(-t))
-
-def sigmoid(t):
- """
- Returns the Sigmoid kernel function evaluated at t
-
- Parameters
- ----------
- t : numpy array, shape (n_samples,)
-
- Returns
- -------
- numpy array, shape (n_samples,)
-
- """
- return 2/(1 + np.exp(-t))
-
-def kernel_weighted_polynomial_regressor(x, y, degree=2, kernel=gaussian, h=1):
- """
- Returns the kernel weighted polynomial regressor
-
- Parameters
- ----------
- x : numpy array, shape (n_samples,)
- y : numpy array, shape (n_samples,)
- degree : int, default=2, degree of polynomial
- kernel : function, default=gaussian, kernel function to use
- h : float, default=1, bandwidth parameter
-
- Returns
- -------
-
- """
- n = x.shape[0]
- K = np.zeros((n,n))
- for i in range(n):
- for j in range(n):
- K[i,j] = kernel((x[i]-x[j])/h)
- X = np.zeros((n, degree+1))
- for i in range(n):
- for j in range(degree+1):
- X[i,j] = x[i]**j
- return np.linalg.inv(X.T.dot(K).dot(X)).dot(X.T).dot(K).dot(y)
-
-def kernel_weighted_polynomial_classifier(x, y, degree=2, kernel=gaussian, h=1):
- """
- Returns the kernel weighted polynomial classifier
-
- Parameters
- ----------
- x : numpy array, shape (n_samples,)
- y : numpy array, shape (n_samples,)
- degree : int, default=2, degree of polynomial
- kernel : function, default=gaussian, kernel function to use
- h : float, default=1, bandwidth parameter, a radius of smoothing
-
- Returns
- -------
- numpy array, shape (n_samples,)
-
- """
- n = x.shape[0]
- K = np.zeros((n,n))
- for i in range(n):
- for j in range(n):
- K[i,j] = kernel((x[i]-x[j])/h)
- X = np.zeros((n, degree+1))
- for i in range(n):
- for j in range(degree+1):
- X[i,j] = x[i]**j
- return np.sign(np.linalg.inv(X.T.dot(K).dot(X)).dot(X.T).dot(K).dot(y))
diff --git a/pca.py b/pca.py
deleted file mode 100644
index d3df636..0000000
--- a/pca.py
+++ /dev/null
@@ -1,72 +0,0 @@
-#-*- encoding: utf-8 -*-
-# Author: Stephen Szwiec
-# Date: 2023-02-19
-# Description: Principal Component Analysis Module
-"""
-Copyright (C) 2023 Stephen Szwiec
-
-This file is part of pyqsarplus.
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program. If not, see .
-
-"""
-import numpy as np
-import pandas as pd
-from sklearn.decomposition import PCA
-from sklearn.preprocessing import StandardScaler
-import matplotlib.pyplot as plt
-from data_tools import train_scale
-
-def pca(X_data, feature_set=None):
- """
- Perform PCA on the data
- Generate a scatter plot of the data
- Optionally: plot the features_set as a projection within the scatter plot
-
- Parameters
- ----------
- X_data : pandas DataFrame, shape = (n_samples, n_features)
- feature_set : list, default = None
-
- Returns
- -------
- None
- """
-
- # scale the data
- X_data = train_scale(X_data)
- # perform PCA
- pca = PCA(n_components=2)
- pca.fit(X_data)
- # get the principal components
- X_pca = pca.transform(X_data)
- # create the loadings of selected features if feature_set is not None
- if feature_set is not None:
- loadings = np.zeros((2, len(feature_set)))
- for i, feature in enumerate(feature_set):
- loadings[:, i] = pca.components_[:, X_data.columns.get_loc(feature)]
- loadings_norm = loadings / np.linalg.norm(loadings, axis=0)
- # plot the data
- plt.scatter(X_pca[:, 0], X_pca[:, 1], alpha=0.5)
- # plot the loadings of selected features if feature_set is not None
- if feature_set is not None:
- for i, feature in enumerate(feature_set):
- arrow_length = 0.5
- arrow_style = '->'
- plt.arrow(0, 0, arrow_length * loadings_norm[0, i], arrow_length * loadings_norm[1, i], color='r')
- plt.text(loadings_norm[0, i] * 1.2, loadings_norm[1, i] * 1.2, feature, color='r')
- plt.xlabel('PC1')
- plt.ylabel('PC2')
- plt.show()
-
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..789dac1
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+[project]
+name = "qsarify"
+version = "0.1"
+authors = [
+ { name = "Stephen Szwiec", email = "Stephen.Szwiec@ndsu.edu" },
+]
+description = "QSARify: A tool for QSAR model development"
+license = "GPL-3.0-or-later"
+homepage = "https://stephenszwiec.github.io/qsarify/"
+readme = "README.md"
+keywords = ["QSAR", "machine learning", "cheminformatics"]
+classifiers = [
+ "Programming Language :: Python :: 3",
+ "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+ "Operating System :: OS Independent",
+ "Development Status :: 2 - Pre-Alpha",
+ "Intended Audience :: Science/Research",
+ "Topic :: Scientific/Engineering :: Chemistry",
+ "Topic :: Scientific/Engineering :: Artificial Intelligence",
+ "Topic :: Scientific/Engineering :: Bio-Informatics",
+ "Topic :: Scientific/Engineering :: Information Analysis",
+ ]
+dependencies = [
+ "numpy",
+ "pandas",
+ "scikit-learn",
+ "scipy",
+ "matplotlib",
+]
+
+[project.urls]
+repository = "https://github.com/stephenszwiec/qsarify"
+issues = "https://github.com/stephenszwiec/qsarify/issues"
+homepage = "https://stephenszwiec.github.io/qsarify/"
+documentation = "https://stephenszwiec.github.io/qsarify/"
diff --git a/src/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/src/.ipynb_checkpoints/Untitled-checkpoint.ipynb
new file mode 100644
index 0000000..fc70966
--- /dev/null
+++ b/src/.ipynb_checkpoints/Untitled-checkpoint.ipynb
@@ -0,0 +1,1599 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "2a56c28f-2cc5-4baa-b30b-4e85453affcb",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "# basic toolkit for the workflow\n",
+ "import pandas as pd\n",
+ "import data_tools as dt\n",
+ "import clustering as cl\n",
+ "import feature_selection_single as fss\n",
+ "import feature_selection_multi as fsm\n",
+ "import cross_validation as cv\n",
+ "import export_model as em"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "70cd653c-efdc-405b-989a-a50d40f5b9a5",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "# in this example, the last column is the response variable (log10 of LD50)\n",
+ "# we use pandas to manipulate the data\n",
+ "dfx = pd.DataFrame(pd.read_csv('28BenzeneDescriptors.csv')).iloc[:,:-1]\n",
+ "dfy = pd.DataFrame(pd.read_csv('28BenzeneDescriptors.csv')).iloc[:,-1]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "9992350f-1431-49d3-9f57-1cef849eb4cc",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
No.
\n",
+ "
AMW
\n",
+ "
Sp
\n",
+ "
Mv
\n",
+ "
Me
\n",
+ "
Ms
\n",
+ "
nBM
\n",
+ "
ARR
\n",
+ "
RBN
\n",
+ "
RBF
\n",
+ "
...
\n",
+ "
PCWTe
\n",
+ "
LDI
\n",
+ "
Hy
\n",
+ "
AMR
\n",
+ "
MLOGP
\n",
+ "
MLOGP2
\n",
+ "
ALOGP
\n",
+ "
GVWAI-80
\n",
+ "
Infective-80
\n",
+ "
BLTD48
\n",
+ "
\n",
+ " \n",
+ " \n",
+ "
\n",
+ "
0
\n",
+ "
1
\n",
+ "
6.510
\n",
+ "
8.284
\n",
+ "
0.649
\n",
+ "
0.971
\n",
+ "
2.000
\n",
+ "
6
\n",
+ "
1.000
\n",
+ "
0
\n",
+ "
0.000
\n",
+ "
...
\n",
+ "
10.100
\n",
+ "
0.062
\n",
+ "
-0.921
\n",
+ "
26.058
\n",
+ "
2.255
\n",
+ "
5.085
\n",
+ "
2.047
\n",
+ "
0
\n",
+ "
0
\n",
+ "
-3.46
\n",
+ "
\n",
+ "
\n",
+ "
1
\n",
+ "
2
\n",
+ "
6.143
\n",
+ "
10.045
\n",
+ "
0.626
\n",
+ "
0.969
\n",
+ "
1.952
\n",
+ "
6
\n",
+ "
0.857
\n",
+ "
1
\n",
+ "
0.067
\n",
+ "
...
\n",
+ "
11.371
\n",
+ "
0.057
\n",
+ "
-0.936
\n",
+ "
31.099
\n",
+ "
2.608
\n",
+ "
6.802
\n",
+ "
2.514
\n",
+ "
0
\n",
+ "
0
\n",
+ "
-3.80
\n",
+ "
\n",
+ "
\n",
+ "
2
\n",
+ "
3
\n",
+ "
8.794
\n",
+ "
9.438
\n",
+ "
0.658
\n",
+ "
1.037
\n",
+ "
3.074
\n",
+ "
8
\n",
+ "
0.889
\n",
+ "
1
\n",
+ "
0.071
\n",
+ "
...
\n",
+ "
2.209
\n",
+ "
0.144
\n",
+ "
-0.636
\n",
+ "
33.383
\n",
+ "
1.797
\n",
+ "
3.229
\n",
+ "
2.000
\n",
+ "
0
\n",
+ "
0
\n",
+ "
-3.03
\n",
+ "
\n",
+ "
\n",
+ "
3
\n",
+ "
4
\n",
+ "
8.068
\n",
+ "
11.199
\n",
+ "
0.636
\n",
+ "
1.024
\n",
+ "
2.933
\n",
+ "
8
\n",
+ "
0.800
\n",
+ "
2
\n",
+ "
0.118
\n",
+ "
...
\n",
+ "
2.441
\n",
+ "
0.130
\n",
+ "
-0.672
\n",
+ "
38.424
\n",
+ "
2.150
\n",
+ "
4.623
\n",
+ "
2.467
\n",
+ "
0
\n",
+ "
0
\n",
+ "
-3.36
\n",
+ "
\n",
+ "
\n",
+ "
4
\n",
+ "
5
\n",
+ "
8.068
\n",
+ "
11.199
\n",
+ "
0.636
\n",
+ "
1.024
\n",
+ "
2.933
\n",
+ "
8
\n",
+ "
0.800
\n",
+ "
2
\n",
+ "
0.118
\n",
+ "
...
\n",
+ "
2.313
\n",
+ "
0.123
\n",
+ "
-0.672
\n",
+ "
38.424
\n",
+ "
2.150
\n",
+ "
4.623
\n",
+ "
2.467
\n",
+ "
0
\n",
+ "
0
\n",
+ "
-3.36
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
5 rows × 676 columns
\n",
+ "
"
+ ],
+ "text/plain": [
+ " No. AMW Sp Mv Me Ms nBM ARR RBN RBF ... \\\n",
+ "0 1 6.510 8.284 0.649 0.971 2.000 6 1.000 0 0.000 ... \n",
+ "1 2 6.143 10.045 0.626 0.969 1.952 6 0.857 1 0.067 ... \n",
+ "2 3 8.794 9.438 0.658 1.037 3.074 8 0.889 1 0.071 ... \n",
+ "3 4 8.068 11.199 0.636 1.024 2.933 8 0.800 2 0.118 ... \n",
+ "4 5 8.068 11.199 0.636 1.024 2.933 8 0.800 2 0.118 ... \n",
+ "\n",
+ " PCWTe LDI Hy AMR MLOGP MLOGP2 ALOGP GVWAI-80 Infective-80 \\\n",
+ "0 10.100 0.062 -0.921 26.058 2.255 5.085 2.047 0 0 \n",
+ "1 11.371 0.057 -0.936 31.099 2.608 6.802 2.514 0 0 \n",
+ "2 2.209 0.144 -0.636 33.383 1.797 3.229 2.000 0 0 \n",
+ "3 2.441 0.130 -0.672 38.424 2.150 4.623 2.467 0 0 \n",
+ "4 2.313 0.123 -0.672 38.424 2.150 4.623 2.467 0 0 \n",
+ "\n",
+ " BLTD48 \n",
+ "0 -3.46 \n",
+ "1 -3.80 \n",
+ "2 -3.03 \n",
+ "3 -3.36 \n",
+ "4 -3.36 \n",
+ "\n",
+ "[5 rows x 676 columns]"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "dfx.head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "daf17e1a-182a-43c3-9b92-68f76eec6b74",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(28, 676)"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "dfx.shape "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "bd7cbef0-6a23-4430-a582-d7c6f9970097",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(22, 549) \n",
+ " (6, 549)\n"
+ ]
+ }
+ ],
+ "source": [
+ "dfx = dt.rm_nan(dfx)\n",
+ "dfx = dt.rm_constant(dfx)\n",
+ "dfx = dt.rm_lowVar(dfx)\n",
+ "dfx = dt.rm_nanCorr(dfx)\n",
+ "xtrain, xtest, ytrain, ytest = dt.sorted_split(dfx,dfy,0.2)\n",
+ "xtrain, xtest = dt.scale_data(xtrain, xtest)\n",
+ "print( xtrain.shape, '\\n', xtest.shape)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "09a250cf-a5c9-465c-ae07-d96f210c413f",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(22, 549) \n",
+ " (6, 549)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# there is also an option to do all of the above as one process\n",
+ "# and also to use a cutoff for autocorrelation of X variables\n",
+ "# while also outputting the autocorrelation matrix \n",
+ "dfx = pd.DataFrame(pd.read_csv('28BenzeneDescriptors.csv')).iloc[:,:-1]\n",
+ "xtrain, xtest, ytrain, ytest = dt.clean_data(dfx, dfy, split='sorted', cutoff=0.9, plot=True)\n",
+ "print( xtrain.shape, '\\n', xtest.shape)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "43ae1c23-786b-4aa3-9794-95e737dcda8d",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/home/charlemagne/projects/GitHub/qsarify/clustering.py:46: RuntimeWarning: divide by zero encountered in divide\n",
+ " I = p_values[:, :, None] * np.log2(p_values[:, None, :] / p_values[None, :, :])\n",
+ "/home/charlemagne/projects/GitHub/qsarify/clustering.py:46: RuntimeWarning: invalid value encountered in divide\n",
+ " I = p_values[:, :, None] * np.log2(p_values[:, None, :] / p_values[None, :, :])\n",
+ "/home/charlemagne/projects/GitHub/qsarify/clustering.py:46: RuntimeWarning: divide by zero encountered in log2\n",
+ " I = p_values[:, :, None] * np.log2(p_values[:, None, :] / p_values[None, :, :])\n"
+ ]
+ },
+ {
+ "ename": "ValueError",
+ "evalue": "operands could not be broadcast together with shapes (22,549,1) (22,22,549) ",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[7], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# creates a feature cluster with 'average' euclidean distance and cutoff of 2\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# this is the tunable part of the system \u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m clust \u001b[38;5;241m=\u001b[39m \u001b[43mcl\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfeatureCluster\u001b[49m\u001b[43m(\u001b[49m\u001b[43mxtrain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43minfo\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mlink\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43maverage\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcut_d\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m)\u001b[49m\n",
+ "File \u001b[0;32m~/projects/GitHub/qsarify/clustering.py:120\u001b[0m, in \u001b[0;36mfeatureCluster.__init__\u001b[0;34m(self, X_data, method, link, cut_d)\u001b[0m\n\u001b[1;32m 118\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mX_data \u001b[38;5;241m=\u001b[39m X_data\n\u001b[1;32m 119\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124minfo\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[0;32m--> 120\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mxcorr \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame(\u001b[43mmutual_information\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_data\u001b[49m\u001b[43m)\u001b[49m, columns\u001b[38;5;241m=\u001b[39mX_data\u001b[38;5;241m.\u001b[39mcolumns, index\u001b[38;5;241m=\u001b[39mX_data\u001b[38;5;241m.\u001b[39mcolumns)\n\u001b[1;32m 121\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 122\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mxcorr \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame(\u001b[38;5;28mabs\u001b[39m(np\u001b[38;5;241m.\u001b[39mcorrcoef(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mX_data, rowvar\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)), columns\u001b[38;5;241m=\u001b[39mX_data\u001b[38;5;241m.\u001b[39mcolumns, index\u001b[38;5;241m=\u001b[39mX_data\u001b[38;5;241m.\u001b[39mcolumns)\n",
+ "File \u001b[0;32m~/projects/GitHub/qsarify/clustering.py:46\u001b[0m, in \u001b[0;36mmutual_information\u001b[0;34m(X_data)\u001b[0m\n\u001b[1;32m 44\u001b[0m p_values \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mwhere(np\u001b[38;5;241m.\u001b[39misnan(X_data\u001b[38;5;241m.\u001b[39mvalues), \u001b[38;5;241m0\u001b[39m, X_data\u001b[38;5;241m.\u001b[39mvalues) \u001b[38;5;66;03m# replace NaNs with 0\u001b[39;00m\n\u001b[1;32m 45\u001b[0m \u001b[38;5;66;03m# calculate Kullback-Leibler divergences using broadcasting\u001b[39;00m\n\u001b[0;32m---> 46\u001b[0m I \u001b[38;5;241m=\u001b[39m \u001b[43mp_values\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlog2\u001b[49m\u001b[43m(\u001b[49m\u001b[43mp_values\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mp_values\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 47\u001b[0m I \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39msum(I, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m 48\u001b[0m \u001b[38;5;66;03m# set diagonal elements to 0 (mutual information with itself is 0)\u001b[39;00m\n",
+ "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (22,549,1) (22,22,549) "
+ ]
+ }
+ ],
+ "source": [
+ "# creates a feature cluster with 'average' euclidean distance and cutoff of 2\n",
+ "# this is the tunable part of the system \n",
+ "clust = cl.featureCluster(xtrain, method='info',link='average', cut_d=2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "bdcca1e4-0411-42e3-93d6-54a7ff99a8ef",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 1 ['HATS3e', 'R3e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 2 ['HATS3u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 3 ['MATS2m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 4 ['R2p+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 5 ['HATS0e', 'R2v+', 'R4e+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 6 ['HATS2e', 'R2e+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 7 ['H2u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 8 ['RTe+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 9 ['BELv4', 'BELe1', 'J3D']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 10 ['BELm6', 'HATS2v', 'HATS4e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 11 ['SPAM', 'Mor11u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 12 ['Mor11e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 13 ['BELv1']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 14 ['HATS1p', 'HATS2p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 15 ['HATS1v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 16 ['MATS3v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 17 ['BEHv2']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 18 ['BEHv4']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 19 ['BELe2', 'BELe4']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 20 ['nC']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 21 ['MATS7v', 'MATS7p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 22 ['Mor22v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 23 ['E3s']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 24 ['HATS2m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 25 ['RTm+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 26 ['R2m+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 27 ['CIC0']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 28 ['BELm4', 'Mor17v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 29 ['BELm2']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 30 ['Mor17u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 31 ['Mor17m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 32 ['R4u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 33 ['R1m+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 34 ['C-001']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 35 ['HATS0p', 'RTp+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 36 ['R1p+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 37 ['R1v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 38 ['R1p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 39 ['X2Av', 'X4Av', 'X5Av']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 40 ['R1e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 41 ['TE2']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 42 ['H1u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 43 ['GATS2m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 44 ['Mor19m', 'Mor19v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 45 ['BELm5']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 46 ['Mor20m', 'Mor20v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 47 ['MATS3p', 'GATS3v', 'GATS3p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 48 ['Mor09m', 'Mor10v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 49 ['Mor11p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 50 ['Mor11m', 'Mor11v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 51 ['Mor07m', 'Mor12m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 52 ['Mor13v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 53 ['RDF020m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 54 ['Mor04m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 55 ['Mor24m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 56 ['Mor31m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 57 ['X0Av', 'X3Av']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 58 ['Mor09v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 59 ['R2p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 60 ['Mor18m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 61 ['Mv', 'HATS3m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 62 ['BELm3', 'Mor10m', 'Mor07v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 63 ['E2p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 64 ['Mor02v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 65 ['Mor02p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 66 ['GATS1v', 'GATS1p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 67 ['Mor19u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 68 ['R1u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 69 ['E1v', 'E1p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 70 ['R4v+', 'R4p+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 71 ['R4m+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 72 ['R5m+', 'R5p+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 73 ['R5v+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 74 ['DISPp', 'R3v+', 'R3p+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 75 ['R3m+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 76 ['HATS3v', 'HATS4v', 'R2v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 77 ['H1p', 'R3v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 78 ['HATSv', 'H0p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 79 ['Dp']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 80 ['Dv']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 81 ['RDF035v', 'RDF035p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 82 ['GATS3m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 83 ['MATS3e', 'GATS3e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 84 ['MATS2e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 85 ['GATS2e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 86 ['Du']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 87 ['MATS6v', 'MATS6p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 88 ['R6m+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 89 ['R6v+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 90 ['R6p+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 91 ['Mor07u', 'Mor07e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 92 ['GATS2p', 'MLOGP', 'ALOGP', 'BLTD48']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 93 ['GATS2v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 94 ['Jhetv']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 95 ['E2u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 96 ['MATS5v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 97 ['MATS5p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 98 ['MATS1v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 99 ['Mor22m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 100 ['X3v', 'HTv']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 101 ['X1v', 'X5v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 102 ['H2v', 'H3v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 103 ['JhetZ']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 104 ['E2m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 105 ['Mor03v', 'H2m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 106 ['H3e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 107 ['SEigZ', 'Mor03p', 'H1m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 108 ['ATS3m', 'BEHm3', 'BEHm4']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 109 ['Mor21m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 110 ['Mor27m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 111 ['Mor23m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 112 ['Mor21v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 113 ['ESpm01d']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 114 ['BEHm2']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 115 ['ARR']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 116 ['H1v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 117 ['HATS5v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 118 ['BEHm1', 'Mor06u', 'H2p', 'R5m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 119 ['Mor26m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 120 ['Mor13m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 121 ['E2v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 122 ['R4v', 'RTv']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 123 ['GATS4v', 'GATS4p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 124 ['GATS5v', 'H3p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 125 ['H4m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 126 ['RDF055v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 127 ['GATS5p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 128 ['SHP2']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 129 ['R4p', 'RTp']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 130 ['GATS6v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 131 ['Mor14v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 132 ['R2u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 133 ['Mor14u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 134 ['Mor16m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 135 ['Mor16v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 136 ['Mor16u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 137 ['Mor26v', 'R1m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 138 ['Me']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 139 ['HATS1m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 140 ['H0e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 141 ['SIC0']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 142 ['Dm']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 143 ['RDF010v', 'R2m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 144 ['RDF010m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 145 ['RDF020u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 146 ['TI2']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 147 ['JGI5']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 148 ['Vindex']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 149 ['Yindex']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 150 ['Lop']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 151 ['Mor12v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 152 ['LDI']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 153 ['Qmean']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 154 ['Mor15v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 155 ['EEig12x']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 156 ['EEig12d']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 157 ['qpmax', 'qnmax']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 158 ['R4e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 159 ['Mor28u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 160 ['Mor28v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 161 ['AAC']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 162 ['Ds']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 163 ['E1u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 164 ['R6e+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 165 ['Mor18v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 166 ['Mor09e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 167 ['Mor20u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 168 ['Mor20e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 169 ['Mor09u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 170 ['GATS4m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 171 ['GATS4e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 172 ['Mor24u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 173 ['Mor14m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 174 ['MATS4m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 175 ['MATS4e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 176 ['GATS1m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 177 ['Mor28m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 178 ['RARS', 'REIG']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 179 ['HATS6m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 180 ['Mor18u', 'Mor18e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 181 ['MAXDN', 'MAXDP']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 182 ['AROM']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 183 ['EEig04x']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 184 ['Ms']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 185 ['Mor26u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 186 ['Mor31u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 187 ['Mor31v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 188 ['MATS1p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 189 ['Mor12u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 190 ['Mor08u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 191 ['EEig11d']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 192 ['EEig11r']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 193 ['E1m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 194 ['MATS2v', 'MATS2p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 195 ['HOMA']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 196 ['PW4']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 197 ['SPH', 'L3u', 'L3v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 198 ['L3m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 199 ['MATS4v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 200 ['MATS4p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 201 ['JGI3']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 202 ['HATS5e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 203 ['L3s']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 204 ['IDDE']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 205 ['L1v', 'L1p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 206 ['RDF065v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 207 ['DP18']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 208 ['H3u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 209 ['HATS7u', 'HATS7e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 210 ['HATS7v', 'R7v', 'R7v+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 211 ['R7u+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 212 ['L1u', 'L1e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 213 ['ATS7p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 214 ['GATS7v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 215 ['Ku', 'Kv', 'Ke']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 216 ['GATS7p', 'R7m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 217 ['GGI6']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 218 ['DECC']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 219 ['Mor29m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 220 ['Mor29v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 221 ['G3v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 222 ['Gm']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 223 ['G2p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 224 ['ICR']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 225 ['E1s']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 226 ['IC1']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 227 ['PJI2']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 228 ['PJI3']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 229 ['IVDE']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 230 ['EEig10d']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 231 ['IC2']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 232 ['Mor22u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 233 ['Mor22e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 234 ['E3m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 235 ['EEig08d', 'EEig09d']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 236 ['GATS5e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 237 ['DISPe']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 238 ['MATS5m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 239 ['MATS5e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 240 ['GATS5m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 241 ['Mor15u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 242 ['Mor15e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 243 ['Mor15m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 244 ['nOHPh']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 245 ['H-050']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 246 ['Hy']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 247 ['MATS6m', 'GATS6m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 248 ['R5u+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 249 ['R6u+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 250 ['C-040']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 251 ['MATS7m', 'MATS7e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 252 ['R5e+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 253 ['EEig11x']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 254 ['Mor08m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 255 ['E3v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 256 ['E3p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 257 ['HATS5u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 258 ['GATS1e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 259 ['Mor32m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 260 ['E3e', 'De']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 261 ['G1v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 262 ['MATS3m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 263 ['JGI4']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 264 ['EEig09r']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 265 ['RPCG']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 266 ['RNCG']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 267 ['E2e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 268 ['H5u', 'R5u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 269 ['MATS1e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 270 ['RTu+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 271 ['H6u', 'H6m', 'H6v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 272 ['E3u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 273 ['MATS1m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 274 ['Mor21u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 275 ['Mor21e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 276 ['SIC1']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 277 ['CIC1']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 278 ['HATS1e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 279 ['Mor13u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 280 ['Mor13e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 281 ['Mor29u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 282 ['R2e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 283 ['ISH']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 284 ['H0u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 285 ['SIC2', 'CIC2']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 286 ['IC4']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 287 ['SIC4', 'CIC4']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 288 ['EEig10r']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 289 ['Mor10u', 'R1e+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 290 ['R3e+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 291 ['R1u+', 'R3u+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 292 ['Mor10e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 293 ['HATS1u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 294 ['E1e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 295 ['R1v+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 296 ['BELv2', 'BELv5']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 297 ['RBF', 'BEHe5']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 298 ['Mor04u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 299 ['ATS5e', 'BELe5']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 300 ['HIC']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 301 ['H4u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 302 ['BELv6', 'HATS4u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 303 ['BEHe3', 'R6u', 'R6e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 304 ['BELv3']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 305 ['BELe3']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 306 ['HATS0u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 307 ['BELe6']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 308 ['H2e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 309 ['RDF070v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 310 ['Mor25m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 311 ['HATS2u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 312 ['R2u+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 313 ['HATS6u', 'HATS6e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 314 ['EEig09x']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 315 ['H1e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 316 ['Qpos']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 317 ['Mor24v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 318 ['PCR']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 319 ['ESpm01r']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 320 ['GGI5']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 321 ['EEig05x']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 322 ['BEHe8']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 323 ['BEHe2']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 324 ['BEHv3']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 325 ['BEHv6']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 326 ['RDF060v', 'L2u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 327 ['R3u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 328 ['Mor32v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 329 ['EEig08r']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 330 ['R4u+']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 331 ['ATS6p', 'Tu']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 332 ['BEHv5']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 333 ['BEHe4']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 334 ['ATS3e', 'R6v', 'R6p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 335 ['BEHe6', 'Mor05u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 336 ['Mor04v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 337 ['ATS5v', 'BEHv1', 'H4v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 338 ['Mor25v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 339 ['Mor30v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 340 ['Mor30p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 341 ['RCI']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 342 ['BELv7', 'BELp7']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 343 ['GVWAI-80']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 344 ['BEHv7']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 345 ['BEHe7']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 346 ['BELm7']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 347 ['Mor27u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 348 ['Mor32u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 349 ['Mor30u', 'Mor30e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 350 ['EEig10x']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 351 ['EEig15d']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 352 ['L2m', 'L2v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 353 ['Infective-80']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 354 ['EEig14d']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 355 ['E2s']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 356 ['EEig13x']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 357 ['ASP', 'Ks']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 358 ['P1m', 'P2m', 'P1s', 'P2s']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 359 ['P1u', 'P2u', 'P1v', 'P2v', 'P1e', 'P2e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 360 ['ATS4v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 361 ['Mor05v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 362 ['R5v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 363 ['R5p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 364 ['ATS3v', 'Tp']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 365 ['Mor23u', 'Mor23v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 366 ['BEHp8']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 367 ['ATS3p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 368 ['ESpm03d', 'ESpm08d']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 369 ['EEig02d']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 370 ['JGI2']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 371 ['MSD', 'J', 'Jhete', 'X4', 'Mor05m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 372 ['GGI4']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 373 ['EEig03x']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 374 ['BEHm5', 'BEHm7']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 375 ['ATS1m', 'ATS4m', 'EEig04d']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 376 ['GNar', 'PW2', 'EEig01x', 'EEig07d']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 377 ['S2K', 'X5A', 'EEig03d', 'EEig05d', 'EEig06d', 'ESpm02d', 'BEHm8', 'GGI2']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 378 ['Mor25u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 379 ['PW3', 'X2A', 'X4sol']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 380 ['PHI', 'X5sol', 'BEHm6']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 381 ['GGI3']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 382 ['Mor27v']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 383 ['IDE', 'HVcpx']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 384 ['DP14', 'SP15']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 385 ['EEig08x']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 386 ['RGyr']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 387 ['SPAN']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 388 ['JGI1', 'JGT']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 389 ['EEig02x']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 390 ['S3K']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 391 ['EEig07x', 'EEig07r', 'BEHv8']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 392 ['VED2', 'DP03']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 393 ['X4A', 'ESpm03u']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 394 ['SEige']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 395 ['X3A']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 396 ['HATS6v', 'HATS6p']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 397 ['Mor30m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 398 ['R6m']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 399 ['X5', 'EEig06x']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 400 ['Mor03u', 'Mor08v', 'Mor03e']\n",
+ "\n",
+ " \u001b[1;46mCluster\u001b[0m 401 ['PW5']\n"
+ ]
+ }
+ ],
+ "source": [
+ "# export the results of the clustering, returning the dictionary we will use later\n",
+ "# optionally, print out everything\n",
+ "# optionally, also graph a dendogram (mostly for tuning rather than visualization)\n",
+ "clusterinfo = clust.set_cluster(verbose=True, graph=False)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "acbe1e18-9c07-4e48-81cf-e60b9adb742f",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "ename": "NameError",
+ "evalue": "name 'clust' is not defined",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[8], line 5\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# this is the important diagnostic for the method:\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# if you have chosen good parameters above\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# then this histogram will show a smooth curvature \u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# resembling either a pareto or skewed gaussian\u001b[39;00m\n\u001b[0;32m----> 5\u001b[0m \u001b[43mclust\u001b[49m\u001b[38;5;241m.\u001b[39mcluster_dist()\n",
+ "\u001b[0;31mNameError\u001b[0m: name 'clust' is not defined"
+ ]
+ }
+ ],
+ "source": [
+ "# this is the important diagnostic for the method:\n",
+ "# if you have chosen good parameters above\n",
+ "# then this histogram will show a smooth curvature \n",
+ "# resembling either a pareto or skewed gaussian\n",
+ "clust.cluster_dist()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "37a5bb2d-b9dc-4f95-bdc6-baa29d073cc1",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Start time: 11:43:20\n",
+ "\u001b[1;42m Regression \u001b[0m\n",
+ "10 => 11:43:20 [0.5646699236881829, ['R2m', 'X2Av']]\n",
+ "20 => 11:43:21 [0.6583947897894367, ['Mor04u', 'X2Av']]\n",
+ "30 => 11:43:21 [0.6583947897894367, ['Mor04u', 'X2Av']]\n",
+ "40 => 11:43:22 [0.7742657151910233, ['Mor04u', 'X5Av']]\n",
+ "50 => 11:43:22 [0.7932755997633875, ['RDF070v', 'X5Av']]\n",
+ "60 => 11:43:22 [0.7932755997633875, ['RDF070v', 'X5Av']]\n",
+ "70 => 11:43:23 [0.7932755997633875, ['RDF070v', 'X5Av']]\n",
+ "80 => 11:43:23 [0.7932755997633875, ['RDF070v', 'X5Av']]\n",
+ "90 => 11:43:24 [0.7932755997633875, ['RDF070v', 'X5Av']]\n",
+ "100 => 11:43:24 [0.7932755997633875, ['RDF070v', 'X5Av']]\n",
+ "110 => 11:43:25 [0.7932755997633875, ['RDF070v', 'X5Av']]\n",
+ "120 => 11:43:25 [0.7932755997633875, ['RDF070v', 'X5Av']]\n",
+ "130 => 11:43:26 [0.7932755997633875, ['RDF070v', 'X5Av']]\n",
+ "140 => 11:43:26 [0.7932755997633875, ['RDF070v', 'X5Av']]\n",
+ "Best score: 0.7932755997633875\n",
+ "Model's cluster info [104, 368]\n",
+ "Finish Time : 11:43:26\n"
+ ]
+ }
+ ],
+ "source": [
+ "# let's try single-threaded feature selection \n",
+ "# giving training set, clusterinfo, and number of components to select for \n",
+ "# model is either regression or classification\n",
+ "# learning is number of total epochs to train\n",
+ "# bank is number a memory of best models filtered \n",
+ "# interval is how often you want updates on progress\n",
+ "# the system returns a list of features it found were best\n",
+ "\n",
+ "# this is a small data set, so smaller bank and intervals are used to show convergence\n",
+ "features = fss.mlr_selection(xtrain, ytrain, clusterinfo, 2, model=\"regression\", learning=150, bank=50, interval=10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "ec1718ed-3022-4554-8627-dbba0b4af243",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Model features: ['RDF070v', 'X5Av']\n",
+ "Coefficients: [ -1.45342979 -96.40117135]\n",
+ "Intercept: -0.07684397375001017\n",
+ "RMSE: 0.250852\n",
+ "R^2: 0.793276\n"
+ ]
+ }
+ ],
+ "source": [
+ "# we can export this model for now \n",
+ "model1 = em.ModelExport(xtrain, ytrain, xtest, ytest, features)\n",
+ "# show summary data \n",
+ "model1.mlr()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "8a1ee23e-c76b-4057-bdf7-9fa88ca57c06",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# show plot of training\n",
+ "model1.train_plot()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "29df8327-de11-4d7c-8117-02c190947f35",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "22\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "model1.williams_plot()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "0cedfc9d-83bd-43a3-908b-0d2cfb489d34",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "R2 0.7932755997633875\n",
+ "Q2 0.7099699197171891\n",
+ "RMSE 0.2508516645820539\n",
+ "coef [ -1.45342979 -96.40117135]\n",
+ "intercept -0.07684397375001017\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "model1.external_set()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "3792e6dc-0949-448d-975e-d98c508640f4",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "model1.model_corr()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "db30bcd2-24ca-4a44-a7ea-6b463da38e62",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAACn5ElEQVR4nO2deXxU1dnHf5OBBBACJgQISVjcEFRsQaGoKCiKrVUwUhEVxQVcQAm0uGA0xv1VFKwWrYpgpQEDiUsrgoZ38paKtlbFqiAKRoEIyKJBWRJm8rx/3LmTWe5y7jp3Js/38zmfSe7c5dw7M/f87rMdHxERGIZhGIZh0oSMZHeAYRiGYRjGTljcMAzDMAyTVrC4YRiGYRgmrWBxwzAMwzBMWsHihmEYhmGYtILFDcMwDMMwaQWLG4ZhGIZh0goWNwzDMAzDpBUsbhiGYRiGSStY3DAMk9JMmjQJHTt2FFrX5/Ph3nvvjfy/aNEi+Hw+fPPNN850zgZSoY8M4zVY3DBMCvLrX/8aRx55JHbu3JnwXkNDA/Lz8zF06FA0NzcnvP/pp59i3Lhx6N27N9q1a4eCggKce+65eOqpp9zoOhPm3nvvhc/ni7QOHTpgwIABKC0txb59+2w5RkVFBebNm2fLvhgmlWBxwzApyPz589HU1IQZM2YkvDd79mzs3r0bzz33HDIyYn/ia9euxSmnnIJPPvkEkydPxtNPP43rr78eGRkZePLJJ93qvmeYOHEiDh48iN69eyetD8888wxefvllPPHEEzj++OPx4IMP4vzzz4cd0/6xuGFaK22S3QGGYYzTt29flJWV4fbbb8ekSZNw3nnnAQA++OADPPvss/jDH/6Ak08+OWG7Bx98EJ07d8YHH3yALl26xLz3/fffW+4XEeHQoUNo37695X25gd/vh9/vT2ofxo0bh65duwIAbrzxRlxyySWorq7G+++/j2HDhiW1bwyTqrDlhmFSlJkzZ2LgwIG4+eabcejQIYRCIdx4443o3bs3ysrKFLfZvHkzTjjhhARhAwDdunVLWLZ48WIMGTIEHTp0wJFHHokzzzwTb7/9duT9Pn364Le//S1WrVqFU045Be3bt8ef//xnAMDChQtx9tlno1u3bsjKysKAAQPwzDPPJBxD3kdtbW1kHyeddBJqa2sBANXV1TjppJPQrl07DB48GB9//LHiuX399dcYPXo0jjjiCPTs2RP33XefrvVDKZ5F7s8///lPDBkyBO3atcNRRx2Fv/zlLwnb//e//8VZZ52F9u3bo7CwEA888AAWLlxoKUbm7LPPBgDU1dVprjd//nyccMIJyMrKQs+ePTF16lT8+OOPkfdHjBiBN998E99++23E9dWnTx9TfWKYVIMtNwyTorRp0wbPPfccTjvtNNx///3o1q0bPvroI6xcuRIdOnRQ3KZ3795477338Nlnn+HEE0/U3H95eTnuvfdenHbaabjvvvuQmZmJf/3rX/jf//3fiKUIADZu3IgJEybghhtuwOTJk9GvXz8AkrvlhBNOwEUXXYQ2bdrgb3/7G26++WY0Nzdj6tSpMcfatGkTLr/8ctxwww248sorMWfOHFx44YV49tlnMXv2bNx8880AgIcffhiXXnopNm7cGONyC4VCOP/88/GrX/0Kjz76KFauXImysjIEg0Hcd999hq/tpk2bMG7cOFx33XW4+uqr8eKLL2LSpEkYPHgwTjjhBABAfX09Ro4cCZ/PhzvvvBNHHHEEXnjhBWRlZRk+XjSbN28GAOTm5qquc++996K8vByjRo3CTTfdhI0bN+KZZ57BBx98gHfffRdt27bFXXfdhYaGBmzbtg1z584FAOHAa4ZJeYhhmJRm2rRp1LZtW+rYsSNNmDBBc923336b/H4/+f1+GjZsGN122220atUqampqilnvq6++ooyMDLr44ospFArFvNfc3Bz5u3fv3gSAVq5cmXCsAwcOJCwbPXo0HXXUUTHL5H2sXbs2smzVqlUEgNq3b0/ffvttZPmf//xnAkCBQCCy7OqrryYAdMstt8T08YILLqDMzEzatWtXZDkAKisri/y/cOFCAkB1dXUJ/fnHP/4RWfb9999TVlYW/f73v48su+WWW8jn89HHH38cWbZnzx7KyclJ2KcSZWVlBIA2btxIu3btorq6Ovrzn/9MWVlZ1L17d9q/f79iH7///nvKzMyk8847L+azefrppwkAvfjii5FlF1xwAfXu3VuzHwyTjrBbimFSnAcffBC5ubnIyMiIPKGrce655+K9997DRRddhE8++QSPPvooRo8ejYKCArzxxhuR9V577TU0NzfjnnvuSQhK9vl8Mf/37dsXo0ePTjhWdNxNQ0MDdu/ejbPOOgtff/01GhoaYtYdMGBATHzJ0KFDAUguml69eiUs//rrrxOON23atJg+Tps2DU1NTaipqVG/ICoMGDAAw4cPj/yfl5eHfv36xRx35cqVGDZsGH7xi19EluXk5OCKK64wdKx+/fohLy8Pffv2xQ033IBjjjkGb775pqr1raamBk1NTSgpKYn5bCZPnozs7Gy8+eabho7PMOkIu6UYJsXJzs5Gv379sHv3bnTv3h2hUAi7du2KWScnJweZmZkAgFNPPRXV1dVoamrCJ598gldffRVz587FuHHjsG7dOgwYMACbN29GRkYGBgwYoHv8vn37Ki5/9913UVZWhvfeew8HDhyIea+hoQGdO3eO/B8tYABE3isqKlJc/sMPP8Qsz8jIwFFHHRWz7LjjjgMAU7Ev8f0BgCOPPDLmuN9++61iwO8xxxxj6FhVVVXIzs5G27ZtUVhYiKOPPlpz/W+//RYAIu4/mczMTBx11FGR9xmmNcPihmHSjK1btyYIjkAggBEjRsQsy8zMxKmnnopTTz0Vxx13HK655hosW7ZMNRhZDaXMqM2bN+Occ87B8ccfjyeeeAJFRUXIzMzEihUrMHfu3IT6O2oZS2rLyYY0aS3cPO6ZZ54ZyZZiGMYeWNwwTJrRo0cPvPPOOzHLlNLCoznllFMAANu3bwcAHH300Whubsb69etj3C6i/O1vf0NjYyPeeOONGCtIIBAwvC8Rmpub8fXXX0esNQDw5ZdfAoBjGUK9e/fGpk2bEpYrLbP7uIAUyB1trWpqakJdXR1GjRoVWRbvQmSY1gLH3DBMmtGuXTuMGjUqph155JEAJHGhZH1YsWIFgBZXx9ixY5GRkYH77rsvwcoiYr2QLR/R6zY0NGDhwoXmTkqAp59+OvI3EeHpp59G27Ztcc455zhyvNGjR+O9997DunXrIsv27t2Lv/71r44cT2bUqFHIzMzEH//4x5jru2DBAjQ0NOCCCy6ILDviiCMS4psYpjXAlhuGaUXccsstOHDgAC6++GIcf/zxaGpqwtq1a/HKK6+gT58+uOaaawBIcSN33XUX7r//fgwfPhzFxcXIysrCBx98gJ49e+Lhhx/WPM55552HzMxMXHjhhbjhhhvw888/4/nnn0e3bt0i1iE7adeuHVauXImrr74aQ4cOxVtvvYU333wTs2fPRl5enu3HA4DbbrsNixcvxrnnnotbbrklkgreq1cv7N271zGrSV5eHu68806Ul5fj/PPPx0UXXYSNGzdi/vz5OPXUU3HllVdG1h08eDBeeeUVzJw5E6eeeio6duyICy+80JF+MYyXYHHDMK2IOXPmYNmyZVixYgWee+45NDU1oVevXrj55ptRWloaU9zvvvvuQ9++ffHUU0/hrrvuQocOHTBw4EBMnDhR9zj9+vXD8uXLUVpaij/84Q/o0aMHbrrpJuTl5eHaa6+1/bz8fj9WrlyJm266CbNmzUKnTp1QVlaGe+65x/ZjyRQVFSEQCODWW2/FQw89hLy8PEydOhVHHHEEbr31VrRr186xY997773Iy8vD008/jRkzZiAnJwdTpkzBQw89hLZt20bWu/nmm7Fu3TosXLgQc+fORe/evVncMK0CHzkdmccwDNOKKCkpwZ///Gf8/PPPSZ/agWFaKxxzwzAMY5KDBw/G/L9nzx68/PLLOOOMM1jYMEwSYbcUwzCMSYYNG4YRI0agf//+2LlzJxYsWIB9+/bh7rvvTnbXGKZVw+KGYRjGJL/5zW+wfPlyPPfcc/D5fBg0aBAWLFiAM888M9ldY5hWTVLdUv/4xz9w4YUXomfPnvD5fHjttdd0t6mtrcWgQYOQlZWFY445BosWLXK8nwzDMEo89NBD+PLLL3HgwAHs378fa9asiakzwzBMckiquNm/fz9OPvlk/OlPfxJav66uDhdccAFGjhyJdevWoaSkBNdffz1WrVrlcE8ZhmEYhkkVPJMt5fP58Oqrr2Ls2LGq69x+++1488038dlnn0WWXXbZZfjxxx+xcuVKF3rJMAzDMIzXSamYm/feey/B5Dt69GiUlJSobtPY2IjGxsbI/83Nzdi7dy9yc3O5NDnDMAzDpAhEhJ9++gk9e/ZERoa24ymlxM2OHTvQvXv3mGXdu3fHvn37cPDgQcUJ/B5++GGUl5e71UWGYRiGYRxk69atKCws1FwnpcSNGe68807MnDkz8n9DQwN69eqFrVu3Ijs7O4k9YxiGYRhGlH379qGoqAidOnXSXTelxE2PHj2wc+fOmGU7d+5Edna2otUGALKyspCVlZWwPDs7m8UNwzAMw6QYIiElKVWheNiwYVi9enXMsnfeeQfDhg1LUo8YhmEYhvEaSRU3P//8M9atW4d169YBkFK9161bhy1btgCQXEpXXXVVZP0bb7wRX3/9NW677TZ88cUXmD9/PiorKzFjxoxkdJ9hGIZhGA+SVHHzn//8B7/85S/xy1/+EgAwc+ZM/PKXv4zM5Lt9+/aI0AGAvn374s0338Q777yDk08+GY8//jheeOEFjB49Oin9ZxiGYRjGe3imzo1b7Nu3D507d0ZDQwPH3DAMw7Qimpub0dTUlOxuMBpkZmaqpnkbGb9TKqCYYRiGYczQ1NSEuro6NDc3J7srjAYZGRno27cvMjMzLe2HxQ3DMAyT1hARtm/fDr/fj6KiIt0CcExyaG5uxnfffYft27ejV69elgrtsrhhGIZh0ppgMIgDBw6gZ8+e6NChQ7K7w2iQl5eH7777DsFgEG3btjW9H5avDMMwTFoTCoUAwLKrg3Ee+TOSPzOzsLhhGIZhWgU8n6D3seszYnHDMAzDMExaweKGYRiGYZi0gsUNwzAMw3iQXbt24aabbkKvXr2QlZWFHj16YPTo0Xj33XcdPa7P54u07OxsnHrqqXj99ddj1qmursa5556LvLw8ZGdnY9iwYVi1apWj/TICixuGYRiGESIEoBbAkvCrtaBXPS655BJ8/PHHeOmll/Dll1/ijTfewIgRI7Bnzx5T+wuFQsJ1fhYuXIjt27fjP//5D04//XSMGzcOn376aeT9f/zjHzj33HOxYsUKfPjhhxg5ciQuvPBCfPzxx6b6ZjvUymhoaCAA1NDQkOyuMAzDMC5w8OBBWr9+PR08eNDCXqqIqJCIENUKw8vt54cffiAAVFtbq7velClTqFu3bpSVlUUnnHAC/e1vfyMiooULF1Lnzp3p9ddfp/79+5Pf76e6ujrdYwOgV199NfL/vn37CAA9+eSTmtsNGDCAysvLdfevhdZnZWT85jo3DMMwDKNJNYBxAOJnK6oPL18OoNjWI3bs2BEdO3bEa6+9hl/96lfIyspKWKe5uRm//vWv8dNPP2Hx4sU4+uijsX79evj9/sg6Bw4cwP/8z//ghRdeQG5uLrp162aoH8FgEAsWLACgnUrf3NyMn376CTk5OYb27xQsbhiGYRhGlRCA6UgUNggv8wEoATAGgF9hHXO0adMGixYtwuTJk/Hss89i0KBBOOuss3DZZZdh4MCBAICamhr8+9//xoYNG3DccccBAI466qiY/Rw+fBjz58/HySefbOj4EyZMgN/vx8GDB9Hc3Iw+ffrg0ksvVV1/zpw5+PnnnzXXcROOuWEYhmEYVdYA2KbxPgHYGl7PXi655BJ89913eOONN3D++eejtrYWgwYNwqJFiwAA69atQ2FhYUTYKJGZmRkRQ0aYO3cu1q1bh7feegsDBgzACy+8oGqVqaioQHl5OSorKw1bhpyCxQ3DMAzDqLLd5vWM0a5dO5x77rm4++67sXbtWkyaNAllZWUAgPbt2+tu3759e1OF8Xr06IFjjjkG5513HhYuXIjx48fj+++/T1hv6dKluP7661FZWYlRo0YZPo5TsLhhGIZhGFXybV7PGgMGDMD+/fsBAAMHDsS2bdvw5ZdfOnrMIUOGYPDgwXjwwQdjli9ZsgTXXHMNlixZggsuuMDRPhiFxQ3DMAzDqDIcQCGk2BolfACKwuvZx549e3D22Wdj8eLF+O9//4u6ujosW7YMjz76KMaMGQMAOOuss3DmmWfikksuwTvvvIO6ujq89dZbWLlypep+77zzTlx11VWG+1NSUoI///nPqK+vByC5oq666io8/vjjGDp0KHbs2IEdO3agoaHB3AnbDIsbhmEYhlHFD+DJ8N/xAkf+fx7sDCYGpGypoUOHYu7cuTjzzDNx4okn4u6778bkyZPx9NNPR9arqqrCqaeeigkTJmDAgAG47bbbNCed3L59O7Zs2WK4P+effz769u0bsd4899xzCAaDmDp1KvLz8yNt+vTpxk/WAXxEpBQCnrbs27cPnTt3RkNDA7Kzs5PdHYZhGMZhDh06hLq6OvTt2xft2rUzuZdqSFlT0cHFRZCEjb1p4K0Zrc/KyPjNqeAMwzAMo0sxpHTvNZCCh/MhuaLstdgw9sDihmEYhmGE8AMYkexOMAJwzA3DMAzDMGkFixuGYRiGYdIKFjcMwzAMw6QVLG4YhmEYhkkrWNwwDMMwDJNWsLhhGIZhGCatYHHDMAzDMExaweKGYRiGYZi0gsUNwzAMw3iQXbt24aabbkKvXr2QlZWFHj16YPTo0Xj33XcdP/bf//53nHXWWejUqRM6dOiAU089FYsWLYpZ55NPPsGECRNQVFSE9u3bo3///njyySeVd+gyXKGYYRiGYUQIhYA1a4Dt24H8fGD4cMDv3PQLl1xyCZqamvDSSy/hqKOOws6dO7F69Wrs2bPH1P5CoRB8Ph8yMrTtGk899RRKSkpw++2345lnnkFmZiZef/113Hjjjfjss88wZ84cAMCHH36Ibt26YfHixSgqKsLatWsxZcoU+P1+TJs2zVQfbYNaGQ0NDQSAGhoakt0VhmEYxgUOHjxI69evp4MHD5rfSVUVUWEhEdDSCgul5Q7www8/EACqra3VXW/KlCnUrVs3ysrKohNOOIH+9re/ERHRwoULqXPnzvT6669T//79ye/3U11dneb+tmzZQm3btqWZM2cmvPfHP/6RAND777+vuv3NN99MI0eO1D9BFbQ+KyPjN7ulGIZhGEaL6mpg3Dhg27bY5fX10vLqatsP2bFjR3Ts2BGvvfYaGhsbFddpbm7Gr3/9a7z77rtYvHgx1q9fj0ceeQT+KGvSgQMH8D//8z944YUX8Pnnn6Nbt26ax12+fDkOHz6MP/zhDwnv3XDDDejYsSOWLFmiun1DQwNycnIEz9I52C3FMAzDMGqEQsD06ZKtJh4iwOcDSkqAMWNsdVG1adMGixYtwuTJk/Hss89i0KBBOOuss3DZZZdh4MCBAICamhr8+9//xoYNG3DccccBAI466qiY/Rw+fBjz58/HySefLHTcL7/8Ep07d0Z+fn7Ce5mZmTjqqKPw5ZdfKm67du1avPLKK3jzzTeNnKojsOWGYRiGYdRYsybRYhMNEbB1q7SezVxyySX47rvv8MYbb+D8889HbW0tBg0aFAnsXbduHQoLCyPCRonMzMyIGLKLzMzMhGWfffYZxowZg7KyMpx33nm2Hs8MLG4YhmEYRo3t2+1dzyDt2rXDueeei7vvvhtr167FpEmTUFZWBgBo37697vbt27eHz+cTPt6xxx6LhoYGfPfddwnvNTU1YfPmzQliav369TjnnHMwZcoUlJaWCh/LSVjcMAzDMIwaCu4ZS+tZZMCAAdi/fz8AYODAgdi2bZuqm8gM48aNQ5s2bfD4448nvPfss8/iwIEDuOqqqyLLPv/8c4wcORJXX301HnzwQdv6YRWOuWEYhmEYNYYPBwoLpeBhpbgbn096f/hwWw+7Z88e/O53v8O1116LgQMHolOnTvjPf/6DRx99FGPGjAEAnHXWWTjzzDNxySWX4IknnsAxxxyDL774Aj6fD+eff77ifu+8807U19fjL3/5i+L7vXr1wqOPPoo//OEPaNeuHSZOnIi2bdvi9ddfx+zZs/HAAw/gxBNPBCC5os4++2yMHj0aM2fOxI4dOwAAfr8feXl5tl4Po7C4YRiGYRg1/H7gySelrCifL1bgyO6eefNsr3fTsWNHDB06FHPnzsXmzZtx+PBhFBUVYfLkyZg9e3ZkvaqqKvzhD3/AhAkTsH//fhxzzDF45JFHVPe7fft2bNmyRfPYM2bMwFFHHYXHH38cTz75ZMRStGTJElx22WWR9ZYvX45du3Zh8eLFWLx4cWR579698c0335g8c3vwESlJ0fRl37596Ny5MxoaGpCdnZ3s7jAMwzAOc+jQIdTV1aFv375o166duZ1UV0tZU9HBxUVFkrApLraln15l7969OOecc5CdnY233noLHTp0cOxYWp+VkfGbY24YhmEYRo/iYuCbb4BAAKiokF7r6tJe2ABATk4OampqcM455+C9995LdneEYLcUwzAMw4jg9wMjRiS7F0khNzcX99xzT7K7IQxbbhiGYRiGSStY3DAMwzAMk1awuGEYhmEYJq1gccMwDMMwTFrB4oZhGIZhmLSCxQ3DMAzDMGkFixuGYRiGYdIKFjcMwzAM00qpra2Fz+fDjz/+mOyu2AqLG4ZhGIbxIJMmTYLP58ONN96Y8N7UqVPh8/kwadIk1/t17733wufzwefzwe/3o6ioCFOmTMHevXsj6+zduxe33HIL+vXrh/bt26NXr1649dZb0dDQ4EofWdwwDMMwjADNAL4B8Gn4tdmFYxYVFWHp0qU4ePBgZNmhQ4dQUVGBXr16udADZU444YTIJJwLFy7EypUrcdNNN0Xe/+677/Ddd99hzpw5+Oyzz7Bo0SKsXLkS1113nSv9Y3HDMAzDMDpsAPAIgHsA3B9+fSS83EkGDRqEoqIiVFdXR5ZVV1ejV69e+OUvfxmzbmNjI2699VZ069YN7dq1wxlnnIEPPvggZp0VK1bguOOOQ/v27TFy5EjTs3e3adMGPXr0QEFBAUaNGoXf/e53eOeddyLvn3jiiaiqqsKFF16Io48+GmeffTYefPBB/O1vf0MwGDR1TCOwuGEYhmEYDTYA+COAjwF0BdAv/PpxeLnTAufaa6/FwoULI/+/+OKLuOaaaxLWu+2221BVVYWXXnoJH330EY455hiMHj064i7aunUriouLceGFF2LdunW4/vrrcccdd1ju3zfffINVq1YhMzNTcz15Nu82bZyf1pLFDcMwDMOo0AzgVQC7AQwAkA3AH34dEF7+Gpx1UV155ZX45z//iW+//Rbffvst3n33XVx55ZUx6+zfvx/PPPMMHnvsMfz617/GgAED8Pzzz6N9+/ZYsGABAOCZZ57B0Ucfjccffxz9+vXDFVdcYTpm59NPP0XHjh3Rvn179O3bF59//jluv/121fV3796N+++/H1OmTDF1PKPwrOAMwzAMo8IWAF8AKALgi3vPB6AQkuVmC4A+DvUhLy8PF1xwARYtWgQiwgUXXICuXbvGrLN582YcPnwYp59+emRZ27ZtMWTIEGzYINmWNmzYgKFDh8ZsN2zYMFN96tevH9544w0cOnQIixcvxrp163DLLbcorrtv3z5ccMEFGDBgAO69915TxzMKW24YhmEYRoWfABwCcITK+0eE3//J4X5ce+21WLRoEV566SVce+21Dh9Nn8zMTBxzzDE48cQT8cgjj8Dv96O8vDxhvZ9++gnnn38+OnXqhFdffRVt27Z1pX8sbhiGYRhGhU4A2gHYr/L+/vD7nRzux/nnn4+mpiYcPnwYo0ePTnj/6KOPRmZmJt59993IssOHD+ODDz7AgAEDAAD9+/fHv//975jt3n//fVv6V1paijlz5uC7776LLNu3bx/OO+88ZGZm4o033kC7du1sOZYILG4YhmEYRoVeAI4HsBUAxb1HALYB6B9ez0n8fj82bNiA9evXw+/3J7x/xBFH4KabbsKsWbOwcuVKrF+/HpMnT8aBAwci6dc33ngjvvrqK8yaNQsbN25ERUUFFi1aFLOf+vp6HH/88QkiSI9hw4Zh4MCBeOihhwC0CJv9+/djwYIF2LdvH3bs2IEdO3YgFAqZuwgGYHHDMAzDMCpkALgYUnbUegANAILh1/Xh5WPhzmCanZ2N7Oxs1fcfeeQRXHLJJZg4cSIGDRqETZs2YdWqVTjyyCMBAL169UJVVRVee+01nHzyyXj22WcjYkTm8OHD2LhxIw4cOGC4fzNmzMALL7yArVu34qOPPsK//vUvfPrppzjmmGOQn58faVu3bjW8b6P4iChejKY1+/btQ+fOnSMpaQzDMEx6c+jQIdTV1aFv376mXSMbIGVNfQEpxqYdJIvN2PArYw9an5WR8ZuzpRiGYRhGh/6Q6ttsgRQ83AmSK4rdH96ExQ3DMAzDCJAB59K9GXth0ckwDMMwTFqRdHHzpz/9CX369EG7du0wdOhQ3QjtefPmRWYZLSoqwowZM3Do0CGXesswDMMwjNdJqrh55ZVXMHPmTJSVleGjjz7CySefjNGjR+P7779XXL+iogJ33HEHysrKsGHDBixYsACvvPIKZs+e7XLPGYZhGIbxKkkVN0888QQmT56Ma665BgMGDMCzzz6LDh064MUXX1Rcf+3atTj99NNx+eWXo0+fPjjvvPMwYcIEw/n4DJOKNAP4BsCn4Vcn57JhGIZJZZImbpqamvDhhx9i1KhRLZ3JyMCoUaPw3nvvKW5z2mmn4cMPP4yIma+//horVqzAb37zG9XjNDY2Yt++fTGNYVKNDQAeAXAPgPvDr4/A+dmIGYZhUpGkZUvt3r0boVAI3bt3j1nevXt3fPHFF4rbXH755di9ezfOOOMMEBGCwSBuvPFGTbfUww8/rDjfBcOkChsA/BHS7MNFkOay2Q/gY0hVU28F19lgGIaJJukBxUaora3FQw89hPnz5+Ojjz5CdXU13nzzTdx///2q29x5551oaGiINDcqIzKMXTRDKhy2G8AAANkA/OHXAeHlr4FdVAzDMNEkzXLTtWtX+P1+7Ny5M2b5zp070aNHD8Vt7r77bkycOBHXX389AOCkk07C/v37MWXKFNx1113IyEjUallZWcjKyrL/BBjGBbZAqohaBMAX954PQCEky84WcP0NhmGMU1tbi5EjR+KHH35Aly5dkt0d20ia5SYzMxODBw/G6tWrI8uam5uxevVqDBs2THGbAwcOJAgYeQKxVjaLBNNK+AlSqfcjVN4/Ivz+T671iGEYt5g0aRJ8Ph9uvPHGhPemTp0Kn8+HSZMmud8xAHv37kVJSQl69+6NzMxM9OzZE9deey22bNkSs97DDz+MU089FZ06dUK3bt0wduxYbNy40fH+JdUtNXPmTDz//PN46aWXsGHDBtx0003Yv38/rrnmGgDAVVddhTvvvDOy/oUXXohnnnkGS5cuRV1dHd555x3cfffduPDCCxVnSWWYVKcTpDls9qu8vz/8fifXesQwrZfmZuCbb4BPP5Vem13wBxcVFWHp0qU4ePBgZNmhQ4dQUVGBXr2cnotcmb179+JXv/oVampq8Oyzz2LTpk1YunQpNm3ahFNPPRVff/11ZN3/+7//w9SpU/H+++/jnXfeweHDhyOzhTtJUqdfGD9+PHbt2oV77rkHO3bswC9+8QusXLkyEmS8ZcuWGEtNaWkpfD4fSktLUV9fj7y8PFx44YV48MEHk3UKDOMovQAcDyl4eABiXVMEYBuAQeH1GIZxjg0bgFdfBb74Ajh0CGjXDjj+eODii4H+Dkb0Dxo0CJs3b0Z1dTWuuOIKAEB1dTV69eqFvn37xqzb2NiIWbNmYenSpdi3bx9OOeUUzJ07F6eeempknRUrVqCkpARbt27Fr371K1x99dWG+3TXXXfhu+++w6ZNmyJhJL169cKqVatw7LHHYurUqXjrrbcAACtXrozZdtGiRejWrRs+/PBDnHnmmYaPLUrSA4qnTZuGb7/9Fo2NjfjXv/6FoUOHRt6rra3FokWLIv+3adMGZWVl2LRpEw4ePIgtW7bgT3/6U1r5CRkmmgwAFwPoCmA9gAYAwfDr+vDysfDAD5lh0pgNG4A//hH4+GOga1egXz/p9eOPpeUbHK7JcO2112LhwoWR/1988cWIhyOa2267DVVVVXjppZfw0Ucf4ZhjjsHo0aOxd+9eAMDWrVtRXFyMCy+8EOvWrcP111+PO+64w1BfmpubsXTpUlxxxRUJ8bHt27fHzTffjFWrVkWOGU9DQwMAICcnx9BxjcL3RIbxOP0hpXv/EsAeAF+GXweB08AZxmmamyWLze7dwIABQHY24PdLrwMGSMtfe81ZF9WVV16Jf/7zn/j222/x7bff4t1338WVV14Zs87+/fvxzDPP4LHHHsOvf/1rDBgwAM8//zzat2+PBQsWAACeeeYZHH300Xj88cfRr18/XHHFFYZjdnbt2oUff/wR/VXMVf379wcRYdOmTQnvNTc3o6SkBKeffjpOPPFEQ8c1Cs8KzjApQH8A/SBlRf0EKcamF/jphGGcZssWyRVVVAT44lIWfT6gsFCy3GzZAvTp40wf8vLycMEFF2DRokUgIlxwwQXo2rVrzDqbN2/G4cOHcfrpp0eWtW3bFkOGDMGGsGlpw4YNMd4RAKoJPHroJfFkZmYmLJs6dSo+++wz/POf/zR1TCOwuGGYFCEDnO7NMG7z009SjM0RKimLRxwB1NdL6znJtddei2nTpgGQJpxOFnl5eejSpUtEMMWzYcMGtGnTJiEeaNq0afj73/+Of/zjHygsLHS8n/zgxzAMwzAqdOokBQ+rJffs3y+938nhlMXzzz8fTU1NOHz4MEaPHp3w/tFHH43MzEy8++67kWWHDx/GBx98gAEDBgCQXEbxczG+//77hvqRkZGBSy+9FBUVFdixY0fMewcPHsT8+fNx8cUXo3PnzgAkC8+0adPw6quv4n//938TRI9TsLhhGIZhGBV69ZKyorZuBeI9MUTAtm1StpTTWdl+vx8bNmzA+vXrFUufHHHEEbjpppswa9YsrFy5EuvXr8fkyZNx4MABXHfddQCAG2+8EV999RVmzZqFjRs3oqKiIiZpBwDq6+tx/PHHa05I/eCDD6JHjx4499xz8dZbb2Hr1q34xz/+gdGjRyMjIwNPPvlkZN2pU6di8eLFqKioQKdOnbBjxw7s2LEjJrXdCVjcMAzDMIwKGRlSunfXrsD69UBDAxAMSq/r10vLx46V1nOa7OxsZGdnq77/yCOP4JJLLsHEiRMxaNAgbNq0CatWrcKRRx4JQErXrqqqwmuvvYaTTz4Zzz77LB566KGYfRw+fBgbN27EgQMHVI/TtWtXvP/++xg5ciRuuOEG9O3bF2eddRZCoRDWrVuH/Pz8yLrPPPMMGhoaMGLECOTn50faK6+8YvFqaOOjVlbad9++fejcuTMaGho0vyQMwzBMenDo0CHU1dWhb9++aNeunal9KNW56d9fEjZO1rlJFRYsWICbb74Zr7zyCsaOHWt6P1qflZHxmwOKGYZhGEaH/v2l+jZbtkjBw506Sa4oNyw2qcB1112HnJwcbNiwAaNHj0b79u2T2h8WNwzDMAwjQEaGc+ne6cDFF1+c7C5EYM3JMAzDMExaweKGYRiGYZi0gsUNwzAM0ypoZfkzKYldnxGLG4ZhGCatkevCNDU1JbknjB7yZ6RUy8cIHFDMMAzDpDVt2rRBhw4dsGvXLrRt2xYZnOLkSZqbm7Fr1y506NABbdpYkycsbhiGYZi0xufzIT8/H3V1dfj222+T3R1Gg4yMDPTq1Qu++FlKDcLihmEYhkl7MjMzceyxx7JryuNkZmbaYlljccMwDMO0CjIyMkxXKGZSC3Y8MgzDMAyTVrC4YRiGYRgmrWBxwzAMwzBMWsHihmEYhmGYtIIDihmGYRgmxWhu5hnKtWBxwzAMwzApxIYNwKuvAl98ARw6BLRrBxx/PHDxxUD//snunTdgccMwDMMwKcKGDcAf/wjs3g0UFQFHHAHs3w98/DGwdStw660scACOuWEYhmGYlKC5WbLY7N4NDBgAZGcDfr/0OmCAtPy116T1WjssbhiGYRgmBdiyRXJFFRUB8bMT+HxAYaFk2dmyJTn98xLslmIYxhuEQsCaNcD27UB+PjB8uPRYyjAMACl4+NAhyRWlxBFHAPX10nqtHbbcMAyTfKqrgT59gJEjgcsvl1779JGWMwwDQMqKatdOirFRYv9+6f1OndztlxdhccMwXiUUAmprgSVLpNdQKNk9cobqamDcOGDbttjl9fXSchY4DANASvc+/ngpcJgo9j0i6SfUv7+0XmuHxQ3DeJHWYskIhYDp0xPv1EDLspKS9BV2DGOAjAwp3btrV2D9eqChAQgGpdf166XlY8dyvRuAxQ3DeI/WZMlYsybxPKMhkh5T16xxr08M42H695fSvX/5S2DPHuDLL6XXQYM4DTwaDihmGC+hZ8nw+SRLxpgx6RFsu327vesxTCugf3+gXz+uUKwFixuG8RJGLBkjRrjWLcfIz7d3PSZ94Ow5TTIyJE81owyLGyY9SJcbYWuzZAwfLhXnqK9XtlbJxTuGD3e/b0zyqK6WLJjRQr+wEHjySaC4OHn9YlIGNmIxNhACUAtgSfjV5eDPdAq+bW2WDL9fGrAA5apkADBvXmoKVcYcrSnmjHEMH5HS41L6sm/fPnTu3BkNDQ3Izs5OdnfSgGoA0wFE34gKATwJwM4nrBCANQC2A8gHMByAv+VGGP81lgfG5ctT60kvFJKEmZ4lo64uvQZ8pSf1oiJJ2KTS58dYQ/7+q7lm0/X7zwhhZPxmccNYoBrAOADxXyH5CXw57BE4KgIq9ATQZ2b63QhlwQbECpxUFWyipItrkTFPba1kedUjEEiPmDPGEEbGb3ZLMSYJQRIcStpYXlYC6y4qWUDFC5h6YM2l6ZlGXFwsCZiCgtjlhYXpK2wASciMGAFMmCC9srBpfbS2mDPGMTigmDHJGiQKjmgIwNbweiNMHkNHQIne39y6EdppeSgultK92ZLBtCZaW8wZ4xgsbhiTCCsLC8fQEVCi9zc3boROZHfIlgyGaS1w9hxjE+yWYkwirCwsHENHGA2HFLvsU3nf55OCUp2+EXJ2B8PYA2fPMTbB4oYxyWkAuuqskwPJtWQ27kZHGPkhJWUBiQLHrRuhF+ZGai0TbDKtg9Yac8bYCosbxgTVAI4GsFtnvb0ARgHoE97GKLJpRoNiSElZcfdB126EyZ4bKZ1q/DCMTHEx8M03UlZURYX0WlfHwoYRhmNuGIOopX9rUR/exmhquGyauUR7tWIAYwCsKQW2D3A3+DaZ2R1qNX5kdxg/5TKpDMecMRZgccMYQCt7SQt5/RsBHIRkZgkX4dOlGEA5gDLt1fwARpwD85lZJklWdkdrm2CTYRjGAOyWYgygl/6txy4AVwIYCclVtQxi0zbcBW33lA9AESTB5DJydkd88KOMU0HNyXaHMepwDBTDJB0WN4wB7HStbANwKSShc3n4tQuAawE0xa0ru6d8UIgcDr/Og5glyGaSld3Bxc68CcdAMYwnYHHDGMDpejE/A1gIoD2A2+LeU40chn3TPJgkGdkdXOzMe3BJAIbxDDy3FKND9ISVGwHcD6DZpWPPAvCoRn+iJtD0Ak1NwPz5wObNwNFHAzffDGRmOnOs1jrBplfhCR8ZxnF44kwNWNwYQWnCSjfxAzgAwCGBYCdOVCgWOWZrnGDTi/CEjwzjODxxJmMDahNWukkIwPwkHl+QZLkjuNiZd+AYKIbxFJwKzihgNuU7nhxI+nmPhX1tttgHh0l2SjZPsOkNOAaKYTwFixtGAasp33LW0PPh13HhZWYEztEW+uECRlKynXJHxBQ783BMUjrDEz4yjKdgtxSjgFXTeXQGk1qWkwh+ADdb7IvDeModUQ2pflB0en0fmJv6gjEET/jIMJ6CxQ2jgBnTeR6AxQACAOoQm5pdDOCb8HsV4ddlADrq7HMmPB9M7Bl3hFqMlDz1BQscx+EYKIbxDJwtxSgQgvTEXw99V5L8lGqm1kwIwBUAKuOO44ckbOLTwD2IJ1Ky5c9LzT3mg2RNqwO7qFwgFOIYKIZxACPjN8fcMArIFYFFYmUKIVUHNvNU6gewFMBfIGVFbYYUY3MzPG+xkZHdEePGSUJGKSXbcXeEXowUAdgaXm+Eg/2wiVQXBzzhI8MkHRY3jApyrEx8nZtCAJMBHAv7AlYzAZRY3EcSkd0RSnVu5s1zwR0hGs+TAmnIyagXxDBM2sFuKUYHzr4RJmkWh1pIwcN6BOBpy41cLyj+lsRFCRmGAVco1oTFDZN+6MVIGYm5SZKY5ekLGIbRgSsUM0yrQo6RAqzNmp7EVHIj9YIYhmF0YHHDMGmB1VnTk5xK7ql6QQzDpDocUMwwaUMxgDEw7lbSmm6DIFl/SsL7dsgl5Jl6QQzDpANJt9z86U9/Qp8+fdCuXTsMHToU//73vzXX//HHHzF16lTk5+cjKysLxx13HFasWOFSbxnG6/ghBQ1PCL+KiBEjqeQOIU9fEF/dV8bnA4qKePoChmGESKq4eeWVVzBz5kyUlZXho48+wsknn4zRo0fj+++/V1y/qakJ5557Lr755hssX74cGzduxPPPP4+C+IqgDJNsQiGgthZYskR6DYWS3SMNPJBKztMXMAxjI0nNlho6dChOPfVUPP300wCA5uZmFBUV4ZZbbsEdd9yRsP6zzz6Lxx57DF988QXatm1r6picLcU4TsrVaqmFZ1LJla5dUZFL9YIYhvEyKZEK3tTUhA4dOmD58uUYO3ZsZPnVV1+NH3/8Ea+//nrCNr/5zW+Qk5ODDh064PXXX0deXh4uv/xy3H777fCrPNE1NjaisbEx8v++fftQVFTE4kYTrm1jmpSs1WJnKrkd3UnxCsUMwzhCSqSC7969G6FQCN27d49Z3r17d+zYsUNxm6+//hrLly9HKBTCihUrcPfdd+Pxxx/HAw88oHqchx9+GJ07d460oqIiW88j/UjFmaVDkKwPS8KvSXIBhUKS1UHpeUFeVlLiQReVXankdnUnPH3BhAnSKwsbhmEMkvSAYiM0NzejW7dueO655zB48GCMHz8ed911F5599lnVbe688040NDRE2tatW13ssdfQEwGpOLO0h8RYStdqsZpKzjAM4x2SlgretWtX+P1+7Ny5M2b5zp070aNHD8Vt8vPz0bZt2xgXVP/+/bFjxw40NTUhMzNxssWsrCxkZWXZ2/mUpBrK80Q9CWng8kA6sGFkMRbfZ1mMuTwop3ytFrOp5AzDMN4iaZabzMxMDB48GKtXr44sa25uxurVqzFs2DDFbU4//XRs2rQJzc3NkWVffvkl8vPzFYUNIyNikfFAOrAh9MQYIIkxF11AaVGrxUwqOcMwjLdIqltq5syZeP755/HSSy9hw4YNuOmmm7B//35cc801AICrrroKd955Z2T9m266CXv37sX06dPx5Zdf4s0338RDDz2EqVOnJusUUgBREVAvuD+vWB08KMa4VgvDMIwnSGqF4vHjx2PXrl245557sGPHDvziF7/AypUrI0HGW7ZsQUZGi/4qKirCqlWrMGPGDAwcOBAFBQWYPn06br/99mSdQgogKgJ2Ce7PK1YHD9RmiUeu1TJunCRkogOLuVYLwzCMa/Cs4GnPEkiBtnosBnAHPJMOrEstPFObJR6u1cIwDGM7RsZvnlsq7RG1tPQAMBlAmcJ7SUgHBnTqnQyHJLb0xFgSXEDFxcCYMSZrtZioMcR1YRiGYWJgcZP2iIiAHABXQz3uphCSsHHR6qBb5VeuzTIO0jlEn1uSxFg0cq0WQ+hltCltkmrVkBkmBeAHhpQnpercMGbQK9BGAPZAXdiUQ3JFuSxsxo1LrBlTXy8tr5Zr2KRTbRYTNYaErxPDMMJUVwN9+gAjRwKXXy699unDv6cUg2Nu0pZ498ZuADOQaBU4CEncKOFUnI2G6yUUkm4kasXwfD7JMlFXF/UklerTRcjTH6gFfit8DqauEyMMP7m3TlJy+pTWQ0rMLZUsWoe4UXNvPAEgDy0iIARglMD+4oNyrYgJHddLba30pKTbpYAJt49XqYXh4OhWeZ1cgl19rRN+YPA8KTG3FOMUWu6N8QD2oqVA2/eC+4xOp7Yy3YGA6yXlq/yawURae6u8Ti7Arr7WS0pPn8LEw+ImrTBatVc0k0pez8rcU4J9y+8m2KWdcKz6cCgkWUaWLJFeHZ/o0ujngDSphuwxnJ741PXvFWMIfmBIK1jcpBVGq/bKmVQqFXXhA1AUXk9UODVBeXJOwb4Nh06VX7lLM+DIBJnV1UDv3rHBhL17O/zEbuRzkDfhasi24+STOwepeh9+YEgrWNykFUbdG3qZVEBLOrWocCqEsstKsG/+76XYBiBx4E7I8LZ5tvLqauCSSyQXRDT19dJyxwYiI5+DvIkfeHIuAFLYJNnVkPVmn/coTj25s6srNeAHhrSCxU1aIfpEEe36UUun7gTgHkizRAPiwil+GgdZgHwluH2+FLS5fDlQENenhAxvGyfIDIWAKVO015kyxUFXgtG09mqgeIbKJoVJzOqwEpOVZJx4cnfa1cXYhzx9CqDwYJXsBwbGKJwtlVbIKcVqBftkugK4EpJwkTOdlgG4HsC+uHVzATwHqdCfSEaPEj60jMAGpncIhYA1TwHbZwgkZVmcZmH1amCUQOZYTQ1wzjnq71tOIRbJRJNjn0hlk0rA/zsDx7SLuH5FkAcKj9cekrNl6uuVxYiZbJl0zGpL9zR5nj7Fs3C2VKsl2r2hxW5Ibg75qfo2AJciUdgAUg2cS8LbaMWFaEGQXFqTw/8bcL2M6N6S3KV5/7QY5Fdba309W+Iq/JBOVu2kFWKfYjbxAf7fw31XkNFgdg/ixJN7ugWptobYoeJi4JtvJMFZUSG91tWxsEkxWNykHWMgCRVREVIP4DGB9W6EVCfHCsfCeEVhE5lEycC1uAqjQeNu4dV+GUTVJWrS1ZdOQaqtKXZInj5lwgTpNZ0sU60ES+KmqakJGzduRDAYtKs/jCWWQ3IfvQJtt1Q0ouvtAbAhvG+zP/R8SALmG0hupIrwq9b0DiYyicwg6hJQWs/VuAoTNXFcwav9MoGdT+5eClK1korOsUNMimFK3Bw4cADXXXcdOnTogBNOOAFbtmwBANxyyy145JFHbO0gI8ptAH4HZdeSXTwJSTwZvYHFCxA910s0JjKJzDBiBJCbq71Obq6yuHG1+JcTliw7spvyBXeTAhYKwL4nd68EqVp1J3GBOybFMCVu7rzzTnzyySeora1Fu3btIstHjRqFV155xbbOMaIsg5hrySp7IY1aRrBDgLgwQabfDzz3nPY6zz2nPAi5GldhtyWrGgj1BmpHAksul15DvWE4u6l6N9DHr5EkZZOFzQmcLq5nt6vLKHa4k9ItdohJf8gEvXr1ovfee4+IiDp27EibN28mIqKvvvqKOnXqZGaXrtHQ0EAAqKGhIdldsYkgEXUlIrjUSg2uX0REVTaea4CIKsKvQZv2G0VVFVFhIZH0LCq1wkJpuRqBQOz6ai0QsKuTROQjCoIoAKKK8GsQ0nLh611FVAWiwrh+FkJarruf8OdRVULkUzhfX7hVGe2Xi5j5vM0SDErfgYoK6TXowPdX6Zjx5xfzGfmIior0++L6d5xhEjEyfpsSN+3bt48Immhxs27dOsrOzjazS9dIP3ETIPeEDYiohogKSRqs1NbJI6LFpC5AXBApVjA6CMkDiM8nPoBYHeiqZhEV+uMGZb+0XOwkiapydURJLql/NlVEVCgJqnhxFL+vIj9RsNLY+blBVZXyZ+bzSc0JgeM2dokSM99xhrEZI+O3KbfUKaecgjfffDPyvy/sO37hhRcwbNgw6+YkxgB2mYFnQNtLKbsVRkA73dwH4FkAV0A5niYFirwZjbcwGldhNf6huhoYNwfYFuc+qW+WlovsJ1QLTN+jk7m9R1ovsQOIzDEmlCQVAtbk6ffJTVpLgKxd7iSvxA4xjChm1NOaNWuoY8eOdOONN1K7du1o+vTpdO6559IRRxxB//nPf8zs0jXSz3JTQ/ZYZAJEtEzlPR8luhVmEZE/bj1/eLkaYXeK0P5txC13gJKLo6go1gKgZi2Qn371rAW2uRlKBZ/oS+M7QJLlLvzZVQjsA5CuvZdoLW4Wu89T5DvOMA7huOXmjDPOwCeffIJgMIiTTjoJb7/9Nrp164b33nsPgwcPtld9MRpUA5hk0762Q3oar4IUsBpNfOBuNYA5SEyHaQ4vV7IcOFzkTS0o1M2iY3opxFrWAkBarmctsCtrxXTmdpypRjh5y2NZUq0lQNbuVHQucMekCkaVU1NTE11zzTX09ddfm1JeySZ9LDdqVhArlhsZrZiYuCd3RStMESXGagRM9EP0UqgEhc6a5a2YCjueoisq7LGUBGoE+1IT3wGK+bzkmBul2B0vx2K0FssNUYu1MP63kE6xRUyrwFHLTdu2bVFVVWW/ymIMoGUFMYpSiq5WHRqzlWgdKvKmleb62GPeiqmIn23czHp2VbwdPgIo1Kjr4wNQlCutF7vj2H81yxB5OBZjV/wErwrYXVzP6ZRzNZKdis4wScCUW2rs2LF47bXXbO4KI46ewBDFTA0asyLFyIzltRAqKCcSFKqGqPvGTkQGVL317HIzvP46cFDlvcjXQqmuj0KdHdUyRB4dPEMhYOZM/fWeeMI+UZbsOZnYncS0MtqY2ejYY4/Ffffdh3fffReDBw/GEUccEfP+rbfeakvnGDWMxgHMAdAbUkZUtCgqhCRsjNzgvhJcL17MyIOi1ozlHSHFEMX38Uko9lEv/kQEN2Mq8gQzhrTWk7NWxo2ThEy0iBO1lMjWLjUBmJMrFSxUHPhkU804SAInvI9iSNOarQGwvQTIH+Pd2aJFvzddu9pzPLXrLRfRc0sAylmADNMKMCVuFixYgC5duuDDDz/Ehx9+GPOez+djceM4RoMze0IajC5GePQJ72M4Wiw2IY33ELXO8wLHK0RiJVp5ULxEY7ufwy2a+nDfFSoR2yFM3Ax0jXcLmF1PdjNMnx47SBcWSsJGa6DUC2oGgPbtgTFjtDoA6fOYjhgh6i8CRsyDLRWjncTNYGI966LPJ7lHx4zxphBkmBTFlLipq6uzux+MIYZD8gEIxnBgPSQXz3BIMTTxVCNhoFK0mIi6wyZD2c01BkAupEk4RSFIFoKS8PZR+7UiTHw+SQy4MWGhjOxS0rIaiMZ5FBdLA+KaNdIgnJ8PnHYasHatFNORn99iOQmFWtbbuVPfarFtm7S+5lN+jKkG6oLYg7g5U7eR7Da2qjCMbZgSN9FQ+InEpxYDwDjA6zA2QeYD4aYkWOSCbPFPlkoWE9En2WNVlq+BMWEjEx2kPKJlsSwW6uv1Y2yiSVaga7RLCTDnUorfnzwgVlcDRx+daMmZMEESO0bdd0JWCznwPMXQ+97YKXydthJFC9doQcswrRxTAcUA8Je//AUnnXQS2rdvj/bt22PgwIF4+eWX7ewbo4gsRn4ysa0sWOQgRqO1Z6zOSG3VzB+3vV7VVJ8PmDVLGqiiSWagqxOZK2oZY9u2SRljZuKSvFaXxk7crLbrpJUo2UHKDONlzOSaP/7449ShQwe67bbb6PXXX6fXX3+dZs2aRR06dKAnnnjCzC5dI7Xr3OjVmBFp0XVoAoLbBMLHV6tgHN2UatzIiB7PYA0cvaqptlUo1qj/Y2Y+quj1GxvN9VGvYrHR5tW6NE7gRrVdp+Zkag3zYjFMHEbGbx+REXu+RN++fVFeXo6rrroqZvlLL72Ee++919MxOfv27UPnzp3R0NCA7OzsZHfHILWQ5mKyg7kA3gbwlsC6FQAuhTQHlJ4VoBLA71TeC4X3oZUxpYQPkkutDqoxHY6b5zXikqqhHNz75JOx1YnV+lddrbz9E09ImVNa51RbKz2x24FstUiWVSsZLpboY3brJi37/nt7jy9b1gBlV6TR6x0KSRYaNYuc7Farq2MXFZNWGBq/zainrKws+uqrrxKWf/nll5SVlWVml66R2pabuOqwrrUA2VdhWK6sLFpd2eF5p4TQmBOrCioza0c9QatVUJbfU3uqj2/yNtGIViwWacmcI0jrGqXD8e20ErWm6soME4WR8dtUQPExxxyDyspKzJ49O2b5K6+8gmOPVQsmZazTLQnHzIOUBVMpuL5eXI1KGjGKAFwGqXif1Vo8dqIRlxQijZClcJrvlCnA3r3KNU4uuQTIzRUPhlaqi2I1NmbuXKB79+QGoya7Dowbx4/Obquvlwo15uUBOTmSJcbIdW8t82IxjAVMuaWqqqowfvx4jBo1CqeffjoA4N1338Xq1atRWVmJiy++2PaO2kXquqWqAUyBuWwjK5RAcmHVQswlFoBYBo1aXR2RejsW0HJ9yO9FDz4Fu4DhM5S7UAv7vISixLscZBeFmYwxJ1wXRl1LyXaxuH18NRdktAtTD1FXZCDA6eVMWuG4W4qI6D//+Q9dccUVNGjQIBo0aBBdccUV9NFHH5ndnWukpluqipLjjop2M8nBzGruJLUJMz2EnntILTC3EJL7Kf6cK2xyB5lp0S4HtYkRtYKGnQg6NePaSbaLxc3j2xUE7FSQMsN4HCPjt2lxk6qknrgRzZDKIKJLBdYz0uLFilq8jBfiYnTQGliEBIGCwKlJoriJn/VbLaZj1iznM4L0rq/WwG3XLOdmcev4elltRgUJz/Qtjm3ZkkyycVzcvPnmm7Ry5cqE5StXrqQVK1aY2aVrpJ64CZC4GOlqYF2RtkyhP1WUKLaKyNPCxo50aR+IikAUDJ9zFSSLTrLEjZIlQe0m7vTNPRgkys01N3C3FsuNE8dxI5U91Ul2oDpjK46Lm5NOOonefPPNhOVvvfUWDRw40MwuXSP1xE2yMqRA6plPGvVevIjowCI0+EA9Qyp+QAekQV/LfSC/b8Sl5DWXQ3m5WN9LSxPFlRsuFi1x55aLxykLEVsl1OFaQGmH4+KmXbt2VFdXl7C8rq6OOnToYGaXrpF64iZAyRM3DrkC3MbOdOnFELPYxKd6a7kPtOJ9vH5TDgaJcnKMXcP4J2cnXSwiT+5uuHiSbaFqbdjtBmQ8gePipnv37rR69eqE5e+88w7l5eWZ2aVrpJ64saMqsdkWcP703MBOy83cqWLr1dS0HF/EfRD/BL5smXddDtF9nTvX+DVUEg1OuFiMPLk77eLhIGB3YTGZljgubqZMmUInnXQSbdq0KbLsq6++ooEDB9J1111nZpeukXrihsj9bKkUyHwygt7AIjogFxURLV4stn68e8GM+8CLLgdRK5Po9Yx3Edl1viJxVnl50ucpH8vp681BwO4haq0tKUl2TxkDOC5ufvzxR/rVr35Fbdq0oT59+lCfPn3I7/fTyJEj6YcffjCzS9dgcSMibDye+WQGrYFFdDCuqkrOE6FXRI6RasqiLdmBwnJzK8iUg4Ddwcjnz9c+ZXB8bqlwfRy88847+OSTT9C+fXucfPLJGD58uJlduUrqFfGT52MyMbOzKYqQ3IrADqJUQK2oSJoBGkh8L36d4mL9onleLPpmB3rF7sxSUQFMmGDvPgFgyRJppmxR3JxXKxlzaLU2jBS3LCriebhSBCPjtyFx895772HPnj347W9/G1n20ksvoaysDAcOHMDYsWPx1FNPISsry3zvHSb1xE0tnC2DWwhgMoBj4UhFYK8hWqF4505gzx4gI0Oq8jpiROxEl3ZOhKiG2rQAyZjg0s4JOqNxqoruffcBZWXGtuEJJ9OL6mppihMRuJpzSuBYheLzzz+fHnnkkcj///3vf6lt27Z0/fXX0+OPP049evSgsrIyI7t0ndRzSxlJBc82sO40ci6NO8VSxeMRzbBxIwDVSMyK6H7NuLjMZJz5/fb3X/QcrcQFcZBp+lBSIvaZO1UkkrEVx2JuevToQR988EHk/9mzZ9Ppp58e+b+yspL69+9vZJeuk1riJkhEc0lMrJQTUYnguqDETCi7BIlSkb9CSokYnmBQvWaLUtCnk7EwbhV9E401Ee3P3LmxGV9OBdBqXXur2XE80KUPnDWVVjgmbrKysmjLli2R/08//XR64IEHIv/X1dVRx44djezSdVJH3CiJBLVWSC3iRGT9PEqcVsEOQSJPzxB/vBQIUq6qIioo0L4B+nxERYVEwRqi4GKiwFyiinC2TWOjvULH7qJvVguamU1ldirFW0ukWa1rxANd+sAp+GmFY+KmV69e9H//939ERNTY2Ejt27enmqh6Hv/973/pyCOPNNhdd0kNcaMmEtSaPFCI1sSJnlbBLkGid2wPp5cbzQIqR2Ihv3gXjNXsG9GqvyIDsV0uLrOpzHZauEREmlnLDQ906Qmn4KcNjombG2+8kYYNG0b/+Mc/aObMmZSbm0uNjY2R9xcvXkynnHKK8R67iPfFjZmifdE/Tj1hNMvAsYwIkoBgXwMiF8E97Jh3Sm2gNHvjrKqydyC20zSfzFRmUZHW2Gi8rhEPdOkNp+CnBY6Jm127dtHw4cPJ5/NRp06dqLq6Oub9s88+m2bPnm2sty7jfXETIGPCRkmAKLmZ8oio0uSxAgL9Fg189lg8g53Vi+2wBIiKLSMDsd0urmTV3TEi0vTqGsVP9MkDXfrjlXpRjGmMjN9tjKRhde3aFf/4xz/Q0NCAjh07wh+XLrls2TJ07NjRyC6ZBLYbXJ8AbIWUMo6o1wWQUrq/h3qKt+ixRNbLF9yX6HoOEp0Ovn69c8chArZulY4lmma6Zo1YLZl77xVPA88XvOai6/n9LefjZs2W7YLf1+3bpdo5y5cr1wiaNw8YM4ZrzbQ2or+3TNpjSNzIdO7cWXF5Tk6Opc4wAPCVye3GAvg5blkugOcgCZs1kERKtNCxU5AMh1Qzpx6S4IrHF34/yYUelYriOY3ooGxk3WOPFd/n8OHSoK5XeNBoEU63CwwaFWnFxdoihgc6Jh4usJg2mBI3jFOEAPzR5LbxwgYA9gC4BJLI2RO1vBDAkwDGwD5B4g/vc1x4u+j9hYvOYR6SWiBQrSie04gOykbWNbJPv18SHOPGSUIm+vzlgoDz5hm7iatdy/p6abkTBQbNiDR+WmdE8Uo1cMYWMpLdASaaWsSKELuI32c9JBHyOiRBArQIEMT9Pw/igqQYwHIABXHLuwKYDiAHkoBziFBIqqS7ZIn0GgrFvjd9unVhk4PES6WGzyeVdjdiEZEHcJ/KQczsE5BuzsuXAwVxn01hoXEhonUt5WUlJbHX3w78fuCJJ9SFDWBcpDEM0CLW4y26slivrk5OvxjTsLjxFLUuHUceHEogWW+UBElheLnRJ5ZiAN8ACIT33xXALkgiaSSkebLM3ihCkK7RkvBrU8v/1fdJc8mMHCnNKTRypPS/fFMSjWXRY3r4VU/gmB1sZStL9D6s7lO+bsWNwDeLgECNNKdTICBNNRAtbLQEoozetYyONbKT6mpg5kzl98yINIYBkifWGWdxIcDZU3g7W6qUjGVK2dEC4WPbPWWC3QX9lDLA/NJrFYh8KhlFclaR1cJuPh9RUS5RsEA6XkKdm7j/nShUZ2qfBgo0ilYwtjv7Sug0dGoRLVumvw+GUYKrGKcMjmVLMU6TDHO6HMDqBzDCpn2GIJk4lFxABMnsUQLJaiRyztWQ3Gjx+wvpHIoka0dJCbBwoVjXAZWQIQLmPQf4m4Hi30ldj47RPg3AWgDbS4D8MdYDEfWCYYVQu26yWzLKMmckhsaJuCAt9FyKPp9k0bn4YnZJMcYxkoXHpAwsbjxDNYD7knBcJ1Kz1wDQcgHJ6etroC+otNSLyKHCLhJAJxgVkifucQAz4/ZZCGBeCVA8BpJbDcpacIQPQBWAObBFqFoKhlW5biEAaygsym4Ehv8WgF/bLC8LxDFjpD45lX2lhhE3GAcPpw5eyUxyW6w7iVeuqQfgmBtPoDOAO4IPQBGcSc22s36OjnoRPdT332vEsoRf5wH4HVpChirCr3UICxsjoi3ZKPS1GpI2GwngcgAjdwF9CoEHHzQWQ+NIXJAG/GSdflRXa8fIuYlTQfxu46Vr6gFY3HgCvUFTj9GQ0r3jkQsq2pEJZQQ76+eoDFhybLFoDb7164GcHOCVVxQyhvyxsdOyVWYCJGuMXxaBGoNnTKzzag8EH8b1VfZQxX/N6ncBZWWCu4zap53ZV3ok48laJLCaMYfXMpPcFutO4LVr6gVciAHyFN4MKBadukCtnUpEi4loDhHNJikwuYakoGClgNIicnaGbnnOKrU5rizOWaUU0CvaCgul4NOYMuyV1BLorBX8rNAXAlEliLoqHCep5fyj+tqo0D8zTSmg0o2S9m7P7CwaWO01UmF6AbsmcXWCVJ1/ysvX1GYcm1sqHfCmuAmQNXET3ZQyYezOhBJBzpbSEwx6xAkltcwo0aY6QaKICFQQbbN0jpW0G2O4r1UgyrMoarxwc3RrZmeRWcfVSKa4SBVB5vXMpFQQiPF4/ZraCIsbDbwpbvQsHUaaqHhwQ/DYZTWqkrZttGGg1hysRa5JlGhbJnCsZIqCqlnGhaDT4sHS+Tj8ZG3lCTiZ4sKKIHObZJQRSHda0TVNOXHz9NNPU+/evSkrK4uGDBlC//rXv4S2W7JkCQGgMWPGCB/Lm+KGSN3SYVbgaLl9RGqf2CV+7NhPlWSBEHWtXCm4nuknmSqp3o2o0ErGE5Po7OLRrbzc+2Z5u5+so/c3d665z9MucWHm3FLNJdGKrAyu0YquaUqJm6VLl1JmZia9+OKL9Pnnn9PkyZOpS5cutHPnTs3t6urqqKCggIYPH54m4oZIWXRYaQGVY+gV1zNQ+C2CloixInCCRFW5xiwQ0wTXs/IkE6gR708ynphEb3jxA2AqmuXNomRtMfp5GhEXWtfWrOUn1QY2t+OnWgOt6JqmlLgZMmQITZ06NfJ/KBSinj170sMPP6y6TTAYpNNOO41eeOEFuvrqq9NI3BDFCoG5ZE3cVMTtr4a0xZOPiHI13lNzd2mJITNCKfpy1BgPHp4ruJ6VG76RisfyQCYqGuwQGEb65zXXhRvoVTwW/d6Iigslq5gsXqxYflLRJeFW/FRropVc05QRN42NjeT3++nVV1+NWX7VVVfRRRddpLrdPffcQ2PHjiUi0hU3hw4dooaGhkjbunWrx8VNNHIsjllxU25xeyWBE+/uUrME6e1HMKg4UGpgkAZREaTYnEKoW3siTzKNZNqiJDqo5eVJ2VmiT+VmnuCVxJCR/qXJjU8YMy67mO9N1PfEyrQe8sCTm6t/zMZGZcGbapYbmVTNTPIyreCapoy4qa+vJwC0du3amOWzZs2iIUOGKG6zZs0aKigooF27dhGRvrgpKysjAAnNW+JGzW1TReqWFL2WS/bE7yi1QFS/zYonwXTwCoPipiq8bzmrSvVJZlZL34MgCoCoIocoUG5PrIPcfv978adyM0/wamJIFlRa1om8PGnQbG0YcdnpfQZm9mWm5eUlfsZVVantkmhNLlC3SPNrmrbiZt++fdSnTx9asWJFZFnqW27U3DazyJo4ybGwrV6TTdwBG/YV0L48orEteQgLG1AkI0v1SSbq2irVzCnMFXva0XNt/P73xuIxjAaG6omhWbOcN1Wn4s3UjLVF7QlYT1w41aI/w1bikkjJ7xpjKykjboy6pT7++GMCQH6/P9J8Ph/5fD7y+/20adMm3WN6K+ZGK7jXTjFidwuE+2+1+CCoRSipEAxKYkMroDgvm6hxFSm6lxJuiI0UEZOqs4lDfFBQElCyK8qIy8Coe0FUDFVW2m+qlq9pSQlR166x+/ZibZV4RK/13LliA6mWuHBa4MiCN91dEqlSx4dxlJQRN0RSQPG0adMi/4dCISooKFAMKD548CB9+umnMW3MmDF09tln06effkqNAiZ274gbq/E0yWjxrqSADfsM6F+qqqqw4Ii/uYeboRtcuM9BaAcq+yBuzld7ojQS7FlSIrZuaamxmBqjwcx66GUYpYK1wAlXjpq4KC83JljMtGjBm46WjVSq48M4SkqJm6VLl1JWVhYtWrSI1q9fT1OmTKEuXbrQjh07iIho4sSJdMcdd6hun7rZUgGyLgxmk7Pup/gWHwRsZ8yNTrq44uBh5sktbG0KGBw4zGAkk8bIYFZYKC6G7MySEc0w8nKch4yetaWkxLhAUBIXIkJKDig2a+nxUiaU3aRaHR8R0lWEukBKiRsioqeeeop69epFmZmZNGTIEHr//fcj75111ll09dVXq26buuLGDpfO4zbsQ7TlkHoauNF9xWdLCaaL23JTCEj7r3Bh4BAZ2AoLiXJyjA1mRgZBu7JkzGQYeS1DJx4lwez3x/5vh+tDJCZGzb2ZDtfZCm5ngzktPNi9ZomUEzdu4h1xEyDrgmO2DfsQbas0zqWSiPwG9hUO+CUisaKCNhC5aS0mCnQlqhEcoEtLrd3k9Aa28eONCYb4gditLBkzWUGpYFGIjh9Su452uD5EYmLiB9bGxtTNhLILN+v4OC082L1mGRY3GnhH3MguHSvBw6UWtjXaFCwpMSxT2U4+v3JKdDnpubUE08VjUHBvKd60QJQL7UBlu25yagPbsmXGrTYizYmbpZkMo1SxKLjl+jBjFWgtmVBquGW5cVp4pKN7LQmwuNHAO+KGyPp8UjVk34Sbek3EkqLkXirS2CYgeOyAxjF1jq82dYNP5W8RwRA9SNXUSE1vwLJSaM9ocyJLxux0DqmA1wvheTkTymk3jht1fNwQHl7/jqUILG408Ja4ITI3n5Rs0WgkySKito5VQaN2XK0fuVJgsFqwsGjckYjJWcG9pZsR5SPKzSYqOFJ80M7NJSooUF/HiIXHSnVbrbZsmcLHYnEQMlLPxeyTbrICLVNhCgMvBqG6FT/itPXKDeGRCt+xFIDFjQbeEzdE0mBv1MU0nogKNN4vIslV5ES6ecDAuWkFCwdsOp6KeysgKAZqaqQbV2mpdWFh5IbrpOXGjkkZI5c3Li5FS+CYtSgkM9CSn6qN43b8iJPWKzeEh1vfMS+KYBthcaOBN8UNkT0BxnIrp9gpHKy4vpSa6I9cL1hYFl9qfRONuQkob280I8ouS4qoGdvJ6rbyTdLqICSSUZSXZy51OvoYon104uadylMYJINkxY84NXC7ITzc+I61gkwsFjcaeFfc6AXXijYlQWDG9aXVAjacj9zPSlIWX0aypRYrH0PUciPftOy2pIjcDNVM7nKbNcvcJI+LF1sfhPTq2lgRNDJG+ujkzbu1B+4aId0sXW6JWye/Y60kE4vFjQbeFDdyTMqt5JwAiY57keN0jFpzjGQvBQz002ggcjxzlfctx9zozg4ePh+7LSmiZmw9k3v0E+vUqWLHnjvX2iDk1tO5aB/LytT7YdfN28uBu14iGQUkncYtcevEd6wVZWKxuNHAe+LGbquK3PRuLGqCQp5U0oolhch4sLBa0LEIKpYbQsv8UQlTN6jctPQsKUaakSdXUZP74sVix168WNzNVlqaeFy3ns5F+6j1edh5807zmAUhtK5BMJg4n5hT3w23cUvc2v0dSzdLmgZGxu82YJJINYBxAMiBfefrvF8MYAyANQC2h9cfDsAP4FcApgPYFrV+IYB54e3sOH78en4AIwS3iadA/a1iAMuhcDqFwLx5QHHc+RQXA8uXA9OnA9uiNigoALZvB5qb9bvj80n7Hz48dnkoBKxZI+0nP1963++X3vP7gREj9PddoHGuZtYDgAceaPm7sBB48kmgsVFs2+3bxY+jRL7g94Q0fiNEwNat0rUVuYZaiH4OXkbre6ZHdXXid1/+ThQXS/vdvVt/P3l5id9/r1NcDIwZY/7aiWL3d0z0N2j1t5pisLhJGiEAt8J+YeODJEREbiyyoAhBEjmVkMTGGMQKn27h9b8HUIsWEaTF8HA/6qF8jkb6qYd8rG3KbxcDGFMIrFkEbP9e/6aldJMLhYBRo8S7NG9e7P71Bg3RAWn4cGm7bSrnCgBFRS0DS2EhUF+vLQ6iqa8Hxo0D7r1XbH1RcaKGfD5G+qhGK7t5K6L3PdPbdty4xM9B/k4sXy4ueq+4wn5R4AapKG5Ff4NWf6uphguWJE/hHbeUWn0aK82o64hIf14nvff19m2Hi0sEtcws+XgWjyXqPsnNVXd1KblTfD7loGGtQFmtQN94V5sZN5s851VBgTsZRHa5AmtqrPcllbESVCoat1FTk1wXCLsNE2lF2X4cc6OBN8RNFdkvbEDGgnDlfmilas/SeV9U4FgJFjaCg8cS9WvHD7BmJpwUGZCMxAcorSvSysvdyyBS6qPRqSncEjfJHGDVjm01qNTI91sv6N6pgbQVpDqbppVk+xkZv31ERMm1HbnLvn370LlzZzQ0NCA7OzsJPQgB6A5gjw37ygBwBYCfAHQEMBHAOdB3Gcn96ANVVw4Q3k9I5T3ZrVQncDzZ7RUf22N2PQPHahoKzP8zsHkzcPTRwM03A5mZBvcJyW3UpztQvwfqXrZcoG5nrDm+thYYOdL48YCW2J26OmUTv5HYiqYmYP586To0NAAvv6x//IoKICsr0c1RVCS53aJdd93CrsvvBdx+asSfj1FXYEUFMGGCsWMaxYrbx8lj5+SIfc8CAWW3y5IlwOWX628vfyfGjZP+jx4+fD7pdfly+6+FmsvMyWOmGkrfD/m3mibXxtD47bjU8hjJt9zY6Y7qqLAsl8QsFQGb+hAwcxEUsOL+UmHWrMSCc36/tNwwwZZ5qhIyr8KtKpcSsrzsKAxox6SAZiw38nGVrAV6+7Tjidqo1cvpbJBk1hLRO7bV9GyjGTdups23olRny6S5247dUhokV9wEiSiHnBE18U3vJiOaqq3X7KhloeceM3HDnDVL+yatKXCU0tIDUp+qkDhfVRcQvSL3ORC7KzsKA1qpF6JXiM/MYFFZKbYPOwZ8kf67Mbglc4AVOXZenthnqyYAzcRtuDWQtqJUZ0YbFjcaJFfcBMgeQZEhsE4hadeKsasv5aavhoRoJWMDN87GxkSLTXzz+6X1ElCzIJW0/P97EGXE7w9E40FUMU05FsJKsGxpqbXJLo0KGy1RsmyZ/rW1e8CvqpICtZ0UUXokc4AVPXZenrWgUq/GbfCkk0wYI+N3htM+MiYau1JVBWqtYBuk2BNAikOpBbAk/BpCS/q0T2MfIjETz0M9LkeENdCO+yEAW9FyLgLMny/Fa2gRCknrxSDXHYrvTz2kGj8AbgPwOBI/ghCAVwBc/rQU+9C7t+QD9/ulmAigJT7AKA88IO2zTx9pn6KsWaOdMq5EYaF6/EJ1NfC73+lfWxkiqf5Mba3UliyRXkW3lykuBnbuBMrLpdgS0f7ayeuvi63nRDq66D6vuEJ6jf+eyf/HlyeIR67xFF8jya1rrAanOjNmcEFseYrkWm6cSP/WahWkHcuil6o9XvA4AQvXRNQ9VqK+i2BQyuIoLZXamDFiT3rTpkXvROE6xV2TRp9koTFiCZGfdtViFGbNEk+D1nqCVnIRWKlQHL9POUvGjOUpPuvJSjxOMmIKqqrEzzWZlptAwJ5YmMZGafqOadOkV0ULp4u0olRnRht2S2mQPHGjVYfFqVaucszoWBat9GmjUyhEoxS3okTAwPmopDmruSz02ty5UYNlqTTRZlDj+HNNHCM3N9ZFpTQwGwn4VbqRq6XIlpebH5DNBiGLnkOqpKeKuvbciLkRHdytCECvplt71WXGuAqLGw2SI270rAJGm19gnZ46x4yOZVETIgHB/gTiztdI5pPKtQlCEhsViBIdcbE3Rp6o45vfT7R0qcKNHFLQsNJ5TjN5LJH6K/KAVFoqts/orBW1LBpZXBl94jUThGxG4KTC07aRgHA3sqWcHNy9PrM0T2za6mFxo0FyxE2AxESCaJslsE4nwX0FNPotCw81i5NSsK+ZzKe4ooZKGUkR0RHur9nieHIbM0blRh5uSgLHjOUGkASLKEaCJ0WyaGRxIzooWr2uRpvXM1xEP4+SEuf74uTgbjUbzC13YZqnOjPacECx57AzyLAcwKMAqgDkaqz3k+D+tPrmBxAOhk0IPJb/n4eWwOMQpBkqSWFf8rISJAYgF4eXQzumdxyA6nBgp5lgWUAKqPz974EPP5Ru28Ld9AE3Fzg/X46R4Em9a0AE7NkjzROlFiQ6ZkxssG9trbnrGk/HjmLreX0+KNHPY8wYZ/sBSAG933wjFeKrqJBe6+rsCfQV+S7Jk5PGU10tBbuPHCkVAjQT/C6KPPfThAnSayrOX8W4AosbV+imv4owx4ZfiwF8B6Crxf2JzB6+HIkzbxeGl0ffWK1kPo0R1EZ/lbJtjAyKV14JTJsGzJ0LHDgA/Pa3Ojfy+G6GhVzmH4GZM8WPK2NkIj55Ikm1zCqfr2ViTNFrcOyxyoMikDgoXXqpeF/jKSuT9l9eDvz8s9g2Xs9wMfJ5uIFTg7vZbDC5cnD870mebNMJgcMwAvCs4ClHPlqmGFgNYLfJ/RiZlbsYsbOEq02NICo4lNYbDqzpCmzTOB8CsHWX9PRoZFC87rpYgSEqCiKrFUKyUBUDj4bF3BNPiKU05+YaEzdy6vi4cdLAGW1dik/pFb0GX32VONuxWjn7vXvF+yoTXeI9FJIEkx7y1BJuiQKzGPk8UpVQCPjrX8XWjf7OhUJSuX9FCyhJ16ekRLJqpfL1YVIStty4wvc27MMHoAiSmOkDYCSAByzsjxDrUtLDD2AEgAnhV6XtRAWH0np+YPuVYptv397yRK1H/AAaCkk1U0TILwUQgDR/VpSF6tFHJQvQ3LnAr3+tvY/nnjN+YxetNzJ8eOI6Sjz/fKwQ0xqU9JBFSU2NsmtE1F1IlDqiwKv1X+xizRpg1y799fLyYn9LVlxZDOMwLG5cwS7T+2UALoW260eUcsS6lOzgNGi7yWSBpvK0ni8Yt7BzJ1BZCUyerL/uk0+2DKBybMCMGdrbRFwN90JVyGVmSk+lK1YAVVWJQquwUFpuduATia/w+4EpU/T3tW1b7ABjNl5JtlQ8+SRwzjnKrhFRq1hJSWqJAifjXZJNfb3YehMmmPusvR5XxaQl7JZyheEA8gAIPB2pciSAF6EckGKGw5DcW3Y9OVdDCphRcyspBSDHIVtj6uvVrQp+f6w4yc0FGhsTYzxycyWriTz4qLlhErop4GqIn716zJjYGbLNzoodT7wrSYljj9V+XyZ6gBEdbHJyYt1UhYX6Mwx7KQDXbkQ+j1RExGoDAH37xv7PlYMZD8PixhX8AIYC+LuFfZiIhdDkAQCLAEyGFKSsFkcjgpzipCUcouJW1NCKb5CJj3PZu1da7957gWBQWjZiRKxFwYgbRm8Ar66W9hVt+SgslPqt+RQvx0lpxSyZwMwAI7pNZaV0DY0INj2BajbWJl5Q2iEeUxGl6wBYuzZ5eebWc+qzZhg7cCE13VMkr4hfHiXWfvFaUyu0F00jEc0lomnh1wOkX6AwL7ydIEr1PLQma9SrwSFaqVeuWKzVL1NFzowUNTSI2dmcnSxnr1cEUHNGdpX9ebFqrtsoXYfc3MQK3UavjZVJQdOtcjDX0fE0XMRPg/Qo4udU0yq0RyQVD4yvjiwyQznI8PxT0TeZuXOt3XxFtgW0ZxUWKXJWWChVI465MZopamgQMwOME4NS9Gc2frz2tRLdv5ZQSsXB0yxGqkYb/QxFCjdqid10qRzMItrzsLjRIDni5reUfOFipMVXHSYSq4qs1dSEQ5CIaoioNNxqEo9tpGpvzK4NVtuVxZHS05uRMvwxN8ZcjWuiVOHZJGYGGDsHJavzYykh8vlFz92VrpipGm3U+mZV7HrZ4iHSN69PPcEQEYsbTdwXN1ZFgdUmOg1DfAtEnUMjic1nJbo/mSoiUhr8cynGomHWbG5EkMgDgdrTW0mJscElupVDe0JOS7OqR2FmgLFjUDI7F5Xe1Auin195ufE+pxJmhLXoNY4mXSww0YhYY6xOPcG4BosbDdwVN3aIgmS1kqjzmGthP2rWiSqBbcM3ILMxIqIWH0C62elNQmmlaU3IKVu11ISG15+Kzc5FFW1pUzpH0c8vJ8db18RujHyPta6xCF7+rhlF1BpjJeaIcRUj4zdnSznKfCTOo2QnHQGIlLnPAfADYCiNfBGAUyBNu/CV4Z5JqKV/y/Ms6DEdwBjzVWJFs4LKy6XU5D59Yvcto7TMKNsgJZTFz1gBAMhXzsIqKADOOAN4553ElGzd7CyXMFszB5AqJwPqGWgidYwA6dqsWZOeadqAtVRqo9umS7q7kerJXK8nPXFBbHkKdy0308i8xcPOVk4tAaxmtu9scr0iUg6YDRg4dqBlM6Nmcz2Lj2yiNhtTY7T5QFSEKBdV2KpVtcyYdchLcQBWrAqFhUSVldpP1x07iu3LqIVCFC9YMkS+x0rXrzW7UoxYY9hykzLwrOCe4WgXjpGDxBm7ZeT5o06HZAXRmkVciwaBdfyQargEAFRAcdqCCAJPQCEAtQCWVEkzVYdCkqVi82Zp2gN5IsxNm9QtGLLFB0ic+NDnk5pcwdiNpzJC1ISc4f6EHgemzzBmHZLXLSkRm98qFIqd+VtkG1GsWBW2bQNuvlnbWpYheIvS6ofZ83dztmsttL7HSqTLnFdWMGKN8drkqIw9uCC2PIX7MTeiqdJmm5pVRv4/PmC3MxENcaAfRmqXBLT3VQUpRiX+KX/WLHOpmiIWHzcsNxErA4goR/rsAjXW9qX3NOl0eqsZq4LRlp2t/p6ehcLs+Xsxe0a0zk2qBwHbgVFrTLrU6/GCpdFBOKBYA3fFTZCIOpJ5waDVogN1lYrEaaUgW2nxYi2DpFT3AImnNAcV+htuVZDcN6IDn12pqiJBy7m59gzigajzrcixtq9x41rOqbEx9hzVXD5yKy+35+anNjDY1dQy1fQ+e7MCxcvZM0rf43Qa0Ow6FzNJCEriMSfHvt+J07SCOj0sbjRwV9wEyB5BoWSViS8AFwwfr4KkWjEq4sFy+wtJ2VPnU2KMTSEpx9gooZAtFUSixUZU4Ngx2Ig8vVVVEXXtam6Qjo+5CYJorg2Dv9ziqzhrVXW2++Znpqp0Xp7YeQUC5uOtzHxnOAYjOdg9OJuxxgSDkpjJybGvH27gRUujA7C40cBdcVNB5gREdLuGEoWKWqCuTMCG46q1ANlXdTeuzk3A4uBux2CjN4hWVREVFJjrnw8t6eBKrrdkNbtufvFP3cuWaQ8uy5YZe7o28lRvRaCYLRrJmMepwdmoKE5FkeBlS6PNsLjRIPUsN4upxSqzmCSryWLSdgPZIaqUmjxHlJZVyGjV3SBFKhRXjLU2SNs12KgNomaL1QFEuYgVNkZcb26IG6dufiJi0YlYBysChS037uL04CwqilNVJLSi7yuLGw3cj7mxGvsSCO9LKa5GzQ0UsHhMtVZiYN9yvw1gNajXyR+vlWJ1AFFN+LqYdb250Zy6fnqDixOVca3c8J2eWJSJxSuDs1f6YZRWZGnkIn5pxS4A1ZAqwFHce/VoqQw3BlKO8XYA3SAV3/tOYRsrjIFQGjdgYL0o5JTM+nrp52iEnJyWVM1QSCrqtn27lCI8fLj1lFizxep8PqCwKzBiV3g/kAr6eRGn0uH1CsMVF0vF1EQ+M9HPVu+75PNJ7yul95otGsmYwytF9LzSD6OIlmOwUrYhBeE6N46yBsAei/uYCalGjdJgLy+bAqAPgJEALgcwCsAhlW3MUgRgOADRH4iJH5LReh7RTJ8uvd53H9Ctm/21Sczc0CID4XzAXwjAZ0rzuYbezc/JejmyAJowQXpVEg5G6s7o1TgCtAVKcTGwfLlUJTqawkJpuReqQ6cLXhmcvdIPo3CdHmVcsCR5itQLKPZCiw4SltO41aodG425UcDIDNOAVMW2rCwxwyHajWA1GNCMyyzGtRIOwg4Y3IcdTS9rSsTNYjaTxa7UXrOBnlZdXumUZu1VvOIG9Eo/zJAudXp04JgbDdwVNzWUfGGi1UQm9VSK65GzpURS1E0SPaiUl7f8UM0O8EZuTGq1RERTlydOJKqpUThWFVGwQIq5cSOgODorSb6GquKgnCQxHqAEYWqnsDCTUms10JMFivdxc3DW+j6kskiYNUu5HMQsIwVWydO/FxY3GrC4AUlBzjVEtIyURYrcykndAqMU4KyXom4Bo9YctWaloq9aMTmlpjqIByUh4Ya4ibdQKFoxcomq4oPeowStWWFhZ0ptqgZ6MsZwIrBc5Bjxv1U3+mE3WpmcRn5vHi8EyOJGA3fFzWKyR4yIWFiMtkC4j1ZESlQaN5WG/3ZQ5QeDkkVEzf0k0rQyBrQGZIBo0iTx44hYNYwWAywq0q8NAxB16kT09tvKT1wxT2XlUZN4RrcoC5wZYWF3Sm0rygZp9ThpNTAiuD1svUjArt9bCtT4YXGjgXvipoqIupL9osSuFj0QyHV0VNwSmucomp5uE06liweD5ovzmb2pNDbqu7q6dCH6y1+U6+3ozXaueTOSY6fUvh/h2KmKxcaFhd2WFrbcuDPYptKAbpRUrWEjgh2/jxS5PjwreNKpBnAJgN3J7ogG0RH/fgAjAEwIv4qkuMrp6fF5zXJ6ukMzJ1tJw9TKGHjwQSlt2E6IgK1bpdTlaOSso6oqaXZzeYbyaORlCxYAEyfGZhCpZfJEU18vpTKrZonp5aQTgK1A/i6tM2whOoPE7pRat7JBnMwGs4Ibs5N7ZQZ0p9Ar5aD2W00F7Pi9peH1YXFjOyFIqdleRk7rNksI+unpJeH1bMZKGub11wOVlYkDV3U1UFZmuWuqRN9U4geRsjKpRk9OTuw2einHxcXA5s1A167K71P4cygpURmkRYVFntQXPXZHCXm7U2qtpnWL4NXBvbpaEqnxA4+uePXYMZJNqtawEcGO31s6Xh8XLEmewnm3lFeDiKNbCRlzP8UTEDxOwOT+NQhWEhX6jQfkZmcru22sVh4WMgfXSH3Xi+kpLzc227Mlc3Sg5XNqhDSB57Twa2PcZ1hZqX+M+DmgnEipdSrQ06uxBm64ClLEHWGZdHZt2vF7S5HrwzE3GjgvbkpJbOBPRsuI+18vPkYtFke0fo/dAZ7hFPQqgR+hXpMHLrUUaTtaZBbwgrAoMzCIiGQtWAq0DcfczAKRP259P6Tlcr0iMzc+p1Jq7Y4L8fLg7saAkyKDmmX0BABAlJurUsIhBbD6e0uRGj8cc8PE0TH82hy3XCs+phqxVY9Hhv+vhqNVilXRcoWZgML7kd0dVklwl4Rf5wHwfwesuVTcpy3qJrBkjvYDtw0GHkOi9zAEafltg6T1zJisnarwK1LJ2AhejjVww1WQqu4Io/FRItXP9+wBRo3yhjvSKFZ/b264ft3GBbHlKVqPW2ocSZaTGiIq0FhPqaKwXKRPaV0fSfVxClXWUdunVQLSvr028WRRkeS2iX/6zwFROVpSrSsE97d4sbglobFRv/qw3y+tF09jI1FGhti2Vieh9HIGjpfTzNlyo4yVWiwi9bKS7Y60gtXfm8dr/LBbSgPnxU2QrM8EbkfLoxa3ksj6gaj+C6QIUyU5XqU4xi0WdvcFBG7ERltOjvnqx3L1z2CNJGZy4t4vhORGE+333Lnig42Vgemaa8T7o5ey7hGTtSm8PLi74SpIEXdEBDvio0TqZXntvN3Eww8k7JZKKn4AzyW7E5BmE5dnCRdBXk8wRRh5kGYjj09HzgFwL6QZxK0Q7xZ7ILabdiJPuqmWjj1G41zmzJFM2K//XTrtvXHvy56/XQDCc2cqIqcz5+WJ9Xn7duD118XXjSYUApYtE9t25Urg6KOBXSop4VZN1slOvxZJM8/Lk1yCbvfPDVdBKrkjQiHpt0qU+J68TDU7MAq/X2p743+scftLsdRn27Db9ZssXBBbnsK9In5lpG8tMdOKiOjXguvKgcAi6wbC/TYaLBwkaZqGnLj3rRTzU3OLwX7Ljex6UTPHKrmc4p/wCguJCjSqDcuBxcvCf2sF/YlaEmpqEjPARK0OVgshxl8jsyZrr5R6FymKmOz+JWNaAg+5I4jIXiubl92RjCrsltLAHXGjVLnXjjaXWqY8EFk/QMZn8Q4Y2Ld8rlrxOdE3R5FKyDpuMTnmxs65meSboZI51k4hEMggqnpFexARdROsWiV2zLy8RLOy6I1dZN9K8TwieC392ujcZeXl7prruUKxvYLEy+5IRhUWNxo4L240rA6WWwWJCad4wSL3SSQ+xogYEo3PCar0W8m6E9C/DlUIW0BsGKD1boZ2CQFACiqmgP4gIpLWWVoqdsxx4xLPyVbBFlC/dmp4Nf1a/lwWLxab98usFcfrIsKr2ClI9KZbac0xNx6GY26Shs3pygl8BeUpD6KJyUEO/10M5fiYwvDy6DRBPwA5PTo+DiF+36LxOQ+q9FspFV0gqKYYwPJxQEGO7qpCaKVUW6mIHM9OAH9dBjz1lBTDkZ8vxXzE+7TtTKM+/nhI38taAEuk1+GnaceZGGH1auPxMl5Nv5ZjDQoKYisuq7Ftm/EKvl6thJwK2DkNx+uvA4cOqe8H8E6sEWMOF8SWp3DWchMgXauD6VZAYq4urVgXEbeQjMhs4aLxOfHxONHNglssGBTPLtJ6OpPTnZWepEXcRHLMjZYlKb5QnsjTv9YTfk2N2DnWlCl8joVEVbPMZ4hZtWR4Pd7BiLXOyBO+11xxqYgdxSHVPge55eQY+yzYEuca7JbSwFlxIzrYm2mTBNersfF89MRQwMbzC0QdU9AtJpLSqTUo+XxSKrdeUKvIDbVqmTVXmdEYjmAjUa5OnZpcX0udnYRr6JMEjplrp3dN9QYGr8c7mHHb6fXVq664VMRK8LPIdCt+P9GyZeb7koyg81ZCyombp59+mnr37k1ZWVk0ZMgQ+te//qW67nPPPUdnnHEGdenShbp06ULnnHOO5vrxpK7lZprgem4+7YoIEdGaP/HZVxqDMlVJNw8tn7leKyqShI3ok7TSTSw3m6i8LGrKhFmJBQbVLDZKzdBNMaA/DUWV1vUOi8Sat81fQ7ODtNdrq4iU6o9velYmrwu6VMOstcSIcNX7LbIlznVSStwsXbqUMjMz6cUXX6TPP/+cJk+eTF26dKGdO3cqrn/55ZfTn/70J/r4449pw4YNNGnSJOrcuTNt27ZN6HjOiptGci6YeKrgegGVvhlxSRlBL1hZTago9VsvWDrsFquqMj/4lpZKN7jGRuNP0sFKovJshUJ9uVHZTpVEga5S8PBck+JA6KYYthJWgaggvj/QETZRLVjjzMSheoO0U3NP2YWe68Lo+XrdFddaMOJy1BLYbIlLCiklboYMGUJTp06N/B8Khahnz5708MMPC20fDAapU6dO9NJLLwmtn7qWGxCRX+O9+NiVaEQzlcyiFZ8TJG3rjdzvZaQtDMsp4orKzTU34EanRRt+kq5qydJKuJGFW2RADgvJimnG+yh8Uwy0XJsgpPo/FeFXRVeUWqvQH8gvuECKbVq8WDxLS2SQ9nptlaoqogIBt53I5+WG5YZjP/Qx6nJU+zzYEpcUUiZbqqmpCR9++CFGjRoVWZaRkYFRo0bhvffeE9rHgQMHcPjwYeTkKGfONDY2Yt++fTHNOZyeXE4tG0UpQ0qmGuKZSmYpBvANgACAivBrXXj56wD2aGxLAB4HMCP8txI+AC9If9bWShPcmeHyy1uyHwxNGBgCQreqJ8LJy0qmhzOG/ABGAPmXGO8jkWCm0HBESh6HD4cJ4VdDCR75LdlZhYWxb2WEbw9vvgnMmAHccQfQtq3gbgWyzIqLgW++AQIBoKJCeq2rMz+ppt0UA/h2LzBeZ73LLtPPqrEz00cJzsISQ/4cRFG7T6TqhKOtiKSKm927dyMUCqF79+4xy7t3744dO3YI7eP2229Hz549YwRSNA8//DA6d+4caUVFRZb7rY6ds2BrEf+xKaV0A9qp6ZERGeqiyQhKI6x8fC1yIU3ZIJJSvkYSN2bp06flb0Mzaq8B1tQLdHFbrCgxeiONRvemqJey74N0bVXnewBQBEkkIVZolJRIy5rjZpGvrwfuvRfIzbVvkPb7pXXz86VzXrPG/SkYFIn67r6rs+rSpdZmpbaaeiw6izwT+zmIoHafMHT/YJJBSte5eeSRR7B06VK8+uqraNeuneI6d955JxoaGiJt69atDvZIoDaGLTQDyAZwK4C5AB6GJBDib7CidWicqieid3xAsurUCu7P4lNQ9LxNhp6ktxuYoitqRb9fmp/FDEI3Rb36RfIcZ3r1isLIQmP5cuXDEcX+bccg7VmLQ/i7K/IVFq3JY2f9Ihm75ltqTRQXA5WV2t9RPZHutCWOsY4LbjJVGhsbye/306uvvhqz/KqrrqKLLrpIc9vHHnuMOnfuTB988IGhYzoXcxMkqRaNkXgHu1t8HI1oanop2RdgHI2R44usFxCv7yLi/xYOag2Iz2kVfQyRtFPTMTfRaAWLi9QrikI0lqC83Hq8jKezTcLf3QrBz81IILCdsTFuxX6kYzzPsmXqv0GR75/Xg+LTkJQLKJ42bVrk/1AoRAUFBZoBxf/zP/9D2dnZ9N577xk+nnPiJkD2CBQrLX46BSN9sjPAWEb0+DVkqLaNmYBiNcEgFNQaJAoWaM9p5QNRUWHsMcxOc2D2pqg6ABnIlDOS1WNlwPNqtknknEolQVsj+JklK3DUjSysdK7lYjWo3etB8WlGSombpUuXUlZWFi1atIjWr19PU6ZMoS5dutCOHTuIiGjixIl0xx13RNZ/5JFHKDMzk5YvX07bt2+PtJ9++knoeM6JGycL+BltOSQJhkbSFg3xAiJ+nimrGCjIZ2T+KyOp4CJPUUKDtEa2lCxu4o9hdl6qKsECYjHds2kAEhVkc+dae4r3YraJ0jUsAFGu1uee5JTf8nJnr6OodS2VLTtW+57K555ipJS4ISJ66qmnqFevXpSZmUlDhgyh999/P/LeWWedRVdffXXk/969exOAhFZWViZ0LOfETQ0lX9TEt0IimkXKokFPbNiFkUk7BV0oRsRNzIzbjUSBuVKKdmCu9L/Rc5nVMbEwnz9DKggYjxnLjQ9ERX6pXo4W0TfU8nLtAWjZspZ1a2qkJt+I46eekOv/GKnxYkZEea3ui+ogrvK3/H8y3Q8itXisiC9R69qyZelr2WE8RcqJGzdJLXGTYXF7WUDMIrF5qeQW0DhPM8UAjcR96Oxf5IablyfVZIl+iqqaRVToj7sB+6XlohiNETFT6TbypA2V60PKFgat5veLv1dYqF65WeuaGx3kvWS50f1OQbLexFefTqb7wUg8l9k+Wpk9nuNOGAdgcaNB6rilfES0lIi62rCfIpJcVKKBu2pPy1aKAdpUIdnMoFg1S3vOp5Lf6puTzcaIVFWZm3OqAqRoRTNaOdfsoPT732uLItHz17ueXpiCQfQ7VTM7bPlbnHz3g5HAb7OYdasm4zNUg11GaUXKFPFLL+yuZ/AHSNXD5lvcD0FK914L4BzBbZTOxWoxQEuV5lowWjwr1ARMfwKq9QEBYN7f9VOQ16xJrCMSDVFsSnAoJNXkaTwI3JsN9BTrdoR8ICFNXyvt1y7kff/lL8bSh+PPXw8n674YRfQ79f2JwIgSYMIVwIgR7vRNDdE+H3us+WNYrdFi9DthN2plBpYtk36bS5ZIr5wmn5awuLGN4QC62rQvH4ClkGqVzLRpn9sRU9VW9bhRhd0i6BUDpPD7LtwkjBbPWjMf2CbYL62iZ0ZEVcxN9UqgbJ90acsBLIb21yThI4g6rp7AsgsiYNcuc9saqcjqRN0XM6RiQTY3+qxXy0WUZFTpVStsuG0bcOmlHqyrxNgNixvb8AM4y6Z9ydaW30G/gpgo+dCuaisf93qF5SKVzLYBeNB074Q57TT9J2a/X1oPALZvFt+3bLVQKnomOkh89ZVKtVgA9wL4BOpWJMXaelHHTYVS7kYHUy9MwSBaSXq3W0U6BXCjiJyIdU0EO0WhbBHVsroYtXByJef0xAU3madwduLMYhKLabGzZRNRO433lTKg9GbfNlsMECQWf2MBo6mvgbnm4gXiA1lFgoNzcoi6djUfo5CLqNm842r7BALik1ba1fLyxON7vBBfYYXKSv1z9Nr5uVVETq2WS2Wlu3FTVVVEBQWxxygoSDxPU1mKKf79bSVwQLEGzombKhIXAG41rdo1QZJm2hbZLmDgmHankkdhJAVcTiEONkpZUYYDehWCqo0c30wrRHhG76jrbzQzKv6GbbYvfj/R0qXKg6fScVI9M8ZL2VtGcKuInFpgrt5vwk6BJXocK4HQXvt8mRg4oNh1QgCmJLsTCqhNqAlIfX5KZTsKv5aE15NjdURwaK4q2dQsimwK92cCT4bjloyEDiiZ0seMkSaNdIptCF+68OdWDWUXlxKym2D8eCAnR/qbSH19PUIhoHt35ZiYeLeg2zEyTuDmLM8irhVRRNx6dhzP75eCqCdMcD+YOhQCrr5ae50pU1rOy4obzA3Xr52fP6OOC2LLUzhjubGzxo1IsT2tbfOIaDFpp1tXhdcT2WcgahvRfthVeC0qfdyIe0kxJVuhzo2aFULNPG2l7odoqyiliCvKiMWmqMh4fRrdvsjWr7in9vjCf+lgyhdOB6+xdhwnpzJQsq44fTw3ptAoKzP22ViqLxWwelW0SeepLFyA3VIaOCNuROvHiLQiIqok8WkTlFpAo69yxWDRfUULFTU3lpHjixIXFyQ6gSGgfqOQKxSX/Lrl5ht/M9Zyr1it+2Hk5io62JaWxlYW1lo3N5do1SqiOXO8caP3EqIDolKMhyhOThSqNGiqzcFmlxvRDVdeMEjUqZP4byH6eoi4VONbpU5lcCt4eqLY1IDFjQbOiJvZJDboq7VsIiqhWGuL2rQFIk3NciLP9WRkXwED29s1fYOCAAsI3pxEi5aZiVVw0nIT/5RrdHoCIwONlwroeQmRAdHsQOSklcNMYUc7PmM3ptAw8puLFjfydTEar+bU996rE8WmGBxz4zpHWtx+H6QU7b1oyQEuhhQvU6C2kQZqPudaGEstz0VszRs5ldyHxAAWxTxmE6jU1NEr0QNIsR933SV2GDMpyHbV/VCCKLZondE6Jq+/Lrb+6tXSq1aKLxFwySVSXZ3WFA+gVncnGgp/L5XKBWhhtAikKGYLO5o9XjTdutm7nhJGYmBGjIj9P/43Pneu/j6cKjro1OfPqMLixhZ+sGk/JYgthFcMYDOAuQDOF9herQgfIEWnXmqwP3sAxA+aaqJLK3jZCCo1dbRK9Ph8UnvySfVAR6UgPjlI8tLwdamslN5ralIO+NOq+2GVkpJYYWWkjkl1tSSMRHjgAaloGaA8kGeEbwnz5rXOAmfFxcCiRdrrmBmInApYtlrYUfR4yQqCFRX52dmJ4gaIDYTu3l1sX04EFbsZsM4AANokuwPpgR0akSBlGtWiZZqEakhWDCM3r3lItJzIUycYfLqDD5LgGhO3z+LwsjWQKujmQxJUdmRQaPy4ZV0Vf0kKC6XBWM3qUl0tPd1GDwKFhS1CJf49vz/25i2vW1zc8nQfv41VevduEVxyH558UsqWUkMWNFMMZurV10uWmZKSloH873+X9hc/aG3bJvUh1bOhjPD992LrGRmInKoobHUwFDme2u9H67sZjej1VEIW+Xq/tQUL9DO4klmJOhWrYKc6LrjJPIX3s6U6khRzYjTwF0Q0XqFvZuJs4lvA0tUxhsC1DIIoMEcsW0criM9IfEJ8nEUwKAXn2hVzA0hF85Yti+3/rFmJE1j6/dJyIvGihlqtoEA9+NTpWAQv4kSgrFNxTmbjwESPZ8fvx2pgul5Mkfxb0CMZsWZyBtvixdoFPjnmRggOKNbAGXETJEmU6AzKhlquyW3ifxwBG/piV2q3CKJCUSAl12g6tdHBoKbGnn2r3az1siuWLZOqIjvRBycGqVTBqUHQiYrCZtKeRY8n8vvx+90RC0rBwXl5xrOb3KrqrNZnK58Hw+JGC2fEjZeqEwfi+mZk6gTRfTqJaH8FBJcT2U3RA7yT0yEsXaqfXZGX59zxldrixfZ+1F7GqUHQiYrCRrOlROuqGPn9uCEW1KokG8WNqs5GPhMnKkqnKUbGb465sUwIwK3J7kQU8T74ryzurxDKAcpOoeFzDiEqzGcnMDyk7WdPZmCgVaZMAfbtU3+fyPzM3WZx+3jJRC22Si++S2S/Y8ZIgcDbt0sxFsOHW6v4K/f1hhvEJvdctAg45xzd1YS/6yUl0vHtvE5KyMHBVnHiM4hGL4PN5wO6dpWytwoK7D02E4HFjWXWQJry2StEi4MQgOcs7u8gpIwpt4JJ5ZzveiA6ADohtnoGUPh4S6CvEk4HBo4YIWUfOYGWsEkWeXnJ7kEioZBzg5TaIAhIGUMix1Trnx2DdHxfDx4ErrxSf12tAN/o/u7cKXbsMWOAOXOc+xycwInPQEYk7XvXLknYONUHBnDBkuQp7HdL2eH2satlENEqaom7CQhuN5LUY4a0Jt90irgChlVQnvhSz/RtpQy70rHi4weCQf1AXKdb1672Trmg1bwWc5OMUvZGjul2/6wGQiv1Nz6YXek3kY7TcVjBjeKGrRSOudHAfnETIDEBYbTJAcVmKhQXkiQQ7BJedlUeNkJ4+oUgpNmyjYiOmN1oxE4o/a14DKiLKKdnCtc778pKd8SN1zI5klHK3sgxk9E/K4HQRuN25POYNYvnSoonVWeYTwFY3Ghgv7gJElFPskdERDc5HdxMGrds9RCdC0q0Bey5ZMIExSfM1LpRaAUQKj6txg/skCbeVNt3MoRN9AApmpXRsaP1Y3mBZJSyN3JMJ/onGkxrJhBaNCsq/vejN1Grl74zbsLTmzgGixsNnMmWslNE5FKsCyhIkqgwOjmnjyRhZGUCzvgWbUaV+1VB2jOQW8QuE6/W4BBsJAp0lSbnDICoMfwq/x8EKVqu7Ew112rx6d5K2RXBoHrNm+iBraTE2LG9mMlhx5Ox0cwbI8e088ld/lzjvwNa1hGj2UCi/Z07N3ZmeJGJWlvrAO5mynkrgsWNBs6IG7vcP12JqFHlGHIxPqNCpZzMT8AZ3wLhvihZlGRXmM24YuINkOZ5BxEWO6WxA6GTE2lGt5oa5YFYaYDWG9iMzjbuxcHJquA1Ewtj5Jh2CfKqKvMzexsRb2b6K/o9Ep3INh1xI+W8lcHiRgNnxE2ArImG6BbQOI6ZmcIryLx7S27RMTdqlZMdCjwWCQrOyZEEgJmBOBgkCpSqW20qkRjzIw+EooOC2aYXI6E2QGtaqdLAZG5F8JqNhXHbciPi7rTrszLTX9Hvfmu23hDZV5uHISIWN5o4I24qybxwiG96EfRGhUogvF20G2muge2jRYtsPdJa14HAYzUTb3wzGsioJBCUsrLUBkI7pj7QO4ZaELOVYNVUN5mLZKkpDapWYmGMiEKrAtKou9NqYKqZ/hqxWnLgLGMTLG40cCagWC2N2kwLUIsQWUySEFkctZyIaBlJLiw9UaImNIy4uIqoxRoTMHAONiMSNGtkcDaaHaJ0rMJC+1LNMzJi/4+ePyoakYGvsFBsziC7TeZuPaWaFTd2pEqLikIrAtKou9OOlGKj/Q0Gxaf+4JRnxiZY3Ghgv7hZRWIDvkjLJaIyUreOFBLRLNIXJSIuIj0XVwm1CCpZbE0TPA87b2ZRFqdgDVHNKv2bqp6p3s5A4PJybauSmQyl6IElflCxM9bBTjFi1k1mBrMixY5YGCOi0KyANOrutMsyYrS/opZLttwwNsHiRgP7xc2VJDbgu9lEg3uVXFzRlhq1dfRaIO44ZjOrFI4d0JhZV/SGamcgcEWF8qCQkyPd/K1MrqnkDjAy8LniXgoSVZWrF1kEEq0sVuugmBUpdgWnGxFrZoSdke+nU7NYi56blgUtFeK3GOu4GFfE4kYD+8XNRWRehDjVagz0X0t4qAUPqzUlV5jZzCqVYy8WvOlrTfJoZyCwPBCq/cDtqJIcPdgaGfgcD+asIgoWaBdZVBv0rMT2iArGmrjfQaoEU4t+Z7wQH5WMYoWMd3C5CreR8TvDzake0hNKdgcU0Jg7JgE/gBEAJoRf5flgQpAmczJ6fvOi9lENYByiJoQKUx9eXq2yjxAQuhWoJWAJgNpwdwBAdO7GmEkeQ+GdhHeW301wJxr4fEBRUctcQ/JcNRMmSK/yvDp+vzT/lbyNGaInMBw+XJqUUIQ9e4AHH0xcHgpJcyMtWSK9hkKJ6+gS/mzX1Cd+vHpQ+DtVUmLy2CaJ/izUmDcv+XMiiXxncnOlySrtnJjSDPKknfHfycJCb/SPcY7qamDcuMR5tOrrpeXVavd3l3BEXnmY1mG5CVg8pyAZy6iSW3ncPkxmVlWVK6RfQ5pjyrDlRsFyFCwgKrRhTiirmVl5eWLHiXeTGKmKHG+9seVJK+qzrbB4Dc3EY1iNnZk1K7HirloAdzLRcncm27oUjxnXRCqkSadCH5NBMqqEE7ulNLFf3FxO1sWIXc2OVGwrNXGiB5OA4DaBuMNXqcRvhFu5kUEzyrUVKcQXfl1mcVA24/KJv1E2NprL+qmqIsrONi4gbHMhRH22AYvX0UwmTTLq3BAlZ6BL18FVRGQn+9yTMTFrqpCk+bNY3Ghgv7iZQuaEgBPNahE9ozE28S0QtS/Rqs1Rg5tIFlNXEOXo/KCKiqQpFWSRVgVlS9CsjtZm9bajvohRcWMmhb2iwuYnrajPVp7YVKQ+kB3XMBiUYmm0MubUzsXKNWgtA50bgkJEYCb7enMskTZJmvmcxY0G9oubU8m4CHCqxc9LZQQ9N5JWU7IYBQS3DURtEjA3QMbffKqqWo5fpTPwVpYpz93jxg/X6FQIIvP5qAkIW5+04j5b+RobEThmzNZWax2ZvQZGB7pkWxy00Oqbmut02TJ7j68nMHNzkysskuRySSnYcuM97BU3QSJqT2RKEDjRROrbqFFj8zFlsaRmCVIQRFazmPLypIkhAwGi4OIWq4LWNrkdW6rKyjf9uXPd+eEaPd+ugmnw8dckGLT5SUvhs1WyjslWKTsqIYtarLTqspi5BkYHumRbHLTQ6pve9f397+0RbFYfYOwQFnri0+6B28ti1yxJyjxkcaOBveImQGRKEIi0Dia3MxN3U0VEOSaPF18XJ36/SoUCVQSRlRtfp05xN+088fic+IJ3Ij/cwkLJPWLlhmVnvR21VlIiHUs0fVpYsCl8tjFxTeGgVzsqIYu4K3Nz9ecXMzNoGdnGy64Mvb4Zdc+aFWx2lWEw+2AhIj7tfBDwstgVQc/S5/I0LixuNLBX3Ng1G7gTLaDR7yC11LYpN7jfOSRZeUQL8i0jory4fagIooiosOHmZ2QfakG7aj9ceRurNyw7auCIDroFBTrXy8yTVhURFcR9toWJn63VJ1c7i+8ZfdoUHegWL/auK8POitxWBzC7BP20aca/S6Li067vm5fFrggiwszlmc9Z3Ghgr7gx68pxo6k9VZjNhjJrEYo/VleSJhpV26TKePyGXSJAqS/xP1y1J1yzNyzRSUHNDD5FRUSVleL7NhxbYbZAo0HsfpI28rQpOtC55co0g1MWQjOCzW5BL/pQYcS9WFmpf1yrU7x4PW7HiDDjCsXeoPWIm4BCf61kQxmN5VE7lkBcUNUyosK4OiRON7Unwegfbk2NPTes+JvBsmXOPFkb3a8h65OFz1eP+Otjt0vNyNOmqLVn8WKxPro1iWT0NSwtdfa3Y1SwiVhFRcWP6EOFqMDT+43LTe9BIEkBt7bgYWHG4kaD9HdLqVlY5CBQM/s0moWld6z4Pka7yQLS/8FKKX5jtoM3ZaMDvB03LDVTb2WltJ0dA1FennQco0/swtYnA5+v0ac6petTUKA94GmlfqtNiVFTI13r0lL9WB0Ra4+XBjORrDI7mxnBpiUwjVozRQZbUeuf6O9P73NMUqq0LXjpuxwHixsNUiegOLrFx6yoBf9qPTVb6WtNeB8KIsTSdQmQtmujSqomnGvx5pttYF2tAd7qDWvZMv1jWo2P6NyZ6C9/kW48otYEowOF6OdbVW4smFLLFK70t9bnpVbdd/z4xPgjEYuVnrXHK/NWmamDZLWZHeSMpqVb6YeRsgtWfuNGj+dFy42HhRmLGw3sTwXPJaEbvSVh8xeSpkNYTFIAsNpTs1bmkhkrU7SFxUh8heixSkjftRGUBkkzN10fiIogVSO2owaLlRtWZWViyX+1YxqZXkGriU7vYPimK/D5qtUX0qoNoxX07PMRdexIlJERu1xp2gSjA7yoxUrPCpWE7JGE/hkVBGazpbR+J3aeTyBAdP75Yv3RGmxFxaddLlCviF0zeFiYsbjRwH5x05F0b/S2NT0hpeUHDhg8VrTA0IuvKKdYa47oseItUvH7jnJdlRsUOHJQclV4f0p1WIz+eEUHj8q4gGkjYkUu2Dd9urG+qt1AzW6r+VSm8/nq1RdSurEb/Xzj9xdvQTGzDzsGG5ezR2IwEzgc7woycr2cFGyysFm8WHyqEZHsJa3toy2ndoiSZItds3hYmLG40SB9A4r1spkaiSjDwP5kK5DRWJ1CkkRWIWkHL3cS3F8pEQWIgo366cwxN220CJvoQTcAomkWngTVXEvxA0Z0fIeZwVa0YN8VVyTW+LGjqQ0UwSBRoIaoIke6lkGFzyxg8BhWLVXRN1urmUF2PI0mq2ibkbgSIxWK//AHdwWbGZeUXKxSb79a+5DPx05RkkyxawWPCjMWNxrYK25mU8KNPektoNJXUSE2m2LjaQIGjy9bc2ZF/W3HeRUSVc3S/sGVl0fdtCspUZSFBZuR9N7GRmuZO04W6tNyc8U3UbGk9VSmGAyNOBHpE58pXGTOKyNNDhK2sg8vBnhGoyWc7HAnaAVhuyHYzMYMycUqtc5L73umV2narChJ1QrFHhRmLG40sFfcXEFky8BtZ1O7OZcKbl8at52VWB0lgWG2hUVS1W+JCuMG6iK1gFCVAGiRCSvVBIToHFTyIGlXRVarbfHilhus7AIy8lSmGuyLWPcfFUnViUUHWTvFn5n5wZT65FX0iqp52J0ghBWhq/e5mRF+qSpK7MTMNXDwurG40SD9xU1Apa9mxU3AYl8aiehxsjU2KabMP6SMKiOp6sGgFJzqpJiQb5Kilh6nW/zN30ytF7V9+0BUlEsUrKFI+rfoIOsV8ef1gV+0qJpH3QlCmBW6Ip+baObg4sWunGra4vB0E0bG7wwwFuid7A7EkQtguMp7IwT30QVAKOr/4QAKAfhM9Od1AEcD+D2An01sr4If0ulMCL/6vwMwDkC12PYPPgj8bGN/ovH5gKIiYPhwoLoauPpqZ45jpj+hEFBbCyxZAuTkAJs3A4EAUFEhvdbVAcXFiftYswbYtk39GARg6x5gjR+AH/D7gSefbDl+fH8AYN48ab38fLHzyM5O3JddxPfJa4RCwPTp0lARj7yspERar7gYWL4cKCiIXa+wUFqu9Pl6he3bja3v80lN5HPbtUtsn6LrMYlUVwPjxiXeK+rrpeXVgvdnu7BFTqUQ3goo7khEZUTUzuJ+olt85pJMkMTT1uNTvNWypbzU4gKqtWIH7HBfqD39y0/Hyag3otcfs09UZuteiFiHRMrxy0UOnZimQqlPXsMLLhU3XDRGLTdGPje23DiLS1WN2S2lgf2p4G2JTA3G7YnoADmbcaUkUkS2i04Dl5ll4Lg+IvKb6O+VNpxzQLsK8KRJxm6gWi1eJMk3WycmKjTTZPGiVxwvJhBb4eZjZHCNHwTjA7LVApVFXClqhfnMXJtJk1InliLZRdXcmtlaxJ2Zl9cSP2bkc/Nw7Za0wKXry+JGA3vFzQEiSwNxJyI60+I+tJqSSFEqxqe2rWwJMZIObtbCU0RSfI5eCrlOqyoxNshZaTU1ygO3kxlSRlpurj3zS4nG0FRWmh8ERWOAzM47Fd8nrwuaaJI5MLs9s7VTMUMiSQS5uan1vfASLglwFjca2CtubiIyOwi71pTq3wRJqngssn2AjAUVF5FUedhoP+Uqs7ILTEHgJAQSK7yfK1jwy0rTM7E6GSQrWtDMyrmpTWegNejMmmV9EDTj+mhsFK/EnApBtUoYzYKyy4WUrAkUnUhBZnHjLGy5ST72iptTSHmg9mKbS7ECRzTFu8LAuqVkrEJxdIsWYArWJaUKwzE1VnxE5S4IG/mmrnWjddJys2qV8y4vtUFr1qzE1Hi/X7nIW7IGQa3m9dgaLay47sy6kJJpMbI7xofdUs7iUhkCFjca2CtuziUyPIgns0XH4AQEtwkYXJdIqlBspn/y9kQtIqlEY54itNRYCYIox+H0btGBQiRINr6Vlbk/95SRG70dAdJ2Dhwi/Sks1I8nSiX0LBp2u5CSHetjJ+l0Ll7FhTIELG40sFfcrCT9AdtLLToGR46j0YpvySEp4FkkFiYvvJ6R+Jz4pnBjCQaJCjXMyfLkmDUWBl3RNm6c+ACp9kNXan6/5F7Rm9rht79tGaStzMUk2uQbvV0B0nYNHCL9ycuTrqno/lKlWJtWFqDd1jMvWjvMflZun0sqfafsxOGqxixuNPBOtpSVlkvWZiOXhYhGfEtMKySx6RQKSUpFN9uvQOIlDggGjJZaGHRFm9EbX1WVeDyIvO9Zs/TXlTO/nHZP2T2FhNL1CwZbpk0oLZX+1hsI7ByoqqoS5ywrKEg995UTg7eXKh7Lgj4+O07U5ebmubiVXeZVuEJxcrBf3FgRGUbbcSRZUuQMpgBJ1g4zgqIrUWTGbz1LiyxqZumsazbLSSnomaS+VQim+jopbpRufKI/YNH6GmbmWRIRQnacr9UAabWBo6pKOcgzN1d7ILDLxSA6kWIq4JTbxQsVj9W+J0b74ca5uJ1d1spgcaOBveImQOSasJFbDkliJnqgEK1fE9+iXVSrSHumblmAHCDJ8mPX+Silq8vn5CPhGaZrIAUYK8Xm2DHYR9+U1OqtlJcnDuBGnqiNWkhyc4l+8xv7zzX+fI30S3TgEIkbUhsI7JogMp2yZ5x0uyRzAkWR74kRq4uT55Ks7LJWBIsbDewVN2YmlbSr5VJs7IyZfciCZRlJlhyRbebafB5FlChsos4pCKJcnZtbbng9OfBYTeCITpYZ3fLyEoWNVhxNvNXB6XmW2rc3vo1WU6stY7bOjdb+9PqiVo/GDheDaH2cmhr1fXgJp90uyYghMWrJFBVuTp2LF2OU0gwWNxqkvuUmuvmIaJLLx5xmsH/x//tIfYoIhesaBFFHnZtFexAdgGTlKQFRXtz70ZWD5ZtaaanYjSi6HLuRm62SINKzaiS7+N/cueo3etFzEBk4jJyn2kBg1cUg+vmXlmrvx0t4wYUUjxUhYfT3kOxMJ87IchwWNxrYH3Nj1mqSqm2u4HrlCtdGyUqjRJRFTDQLKiPu/65diUpK7JlSwOg2QGK2jl3zLDnRRJ/q7TLpG7FQac31Y6U/6ShuiJLrQhLpi1pgrZIIMmrJTLZFhC03jsPiRgN7xQ2R+XiXVGuyC0svLTw6ODg66DlAylYaJQIt+zMbKKz3tGrGjG/0Zhvv0hJ5inV7ws1IrSDBwc8Ok75RkajVN7P9EXVLvf228fPTw2kXjxfSkI0E1qqJICPlDrwQy+Kl7LI0JeXEzdNPP029e/emrKwsGjJkCP3rX//SXL+yspL69etHWVlZdOKJJ9Kbb74pfCz7xU2Q7J3V26stOuhXLYVcLTjYKLJFzGctC0rvZmLUjG/GbWTGHWC08q6VVoRwlWcXn+yNuPeccqmIBBQD9qeFt4Y0YSOBtXoiKDdXX+x7KQvJi67BNCKlxM3SpUspMzOTXnzxRfr8889p8uTJ1KVLF9q5c6fi+u+++y75/X569NFHaf369VRaWkpt27alTz/9VOh49oubMrJfSJSRt9xdeaSczWTW7RSPkoUnLKDsKM6nZQY2YsYPBokKBevWRLfcXLHZseOPVVND1LGj9fOPucmGX0sQNT+XWiq+gxipsuzk9A1Oiqt4C0plpfZAvWyZveeXLEQfAmpq9EWQLEDVrpte2YBk4CXXYJqRUuJmyJAhNHXq1Mj/oVCIevbsSQ8//LDi+pdeeildcMEFMcuGDh1KN9xwg9Dx7I+50UqfNtMKqWVwt3O/Zptc8E/p3GtImk+qlFrq7xhFSSQVUqQGT2PPxHgao00vgM+IGb+qxFy6eYcOsf+LPq3bXYk4YqlRagH9/tiJVv0SpebUrNfxRfzsEFdKA5zW9Bry+5WVxs/BC26oaETdt6JxT+Xl4qUXvEKyPhOvfRdsJmXETWNjI/n9fnr11Vdjll911VV00UUXKW5TVFREc+fOjVl2zz330MCBA4WO6f1sqTJqEQxlJNW1sfsYIk3LxaQlSIzE2cjuLYVjB0EUmERUOsb6gG7roBiQxIFeerpIE7EIiBYBvOWWxGrIRXlEy14hCpSqz6Qe05KQxREMEs2eLXaOTmWZiMbfiH6PrMZNGXnC96KbS9RyIypu5AKXaTxo24IXvws2Y2T8boMksnv3boRCIXTv3j1meffu3fHFF18obrNjxw7F9Xfs2KG4fmNjIxobGyP/NzQ0AAD27dtnpethNtuwD5ksAG0AlMctPxJAMYAAgB9sPJ4ePQE8AmAUgOhr9QaAiQrrbwNwCaT+RvezJ4D/AXBR3PohALcAoMRdvUHA7QC+W2Sq5zEUFAAnnwzY8nkDwMnAqJ7AV98BjwF4CsDPJndFBNx6KzByJOD3K6+zdavYvnr2BDY+BqydCezYC/QAcNouwD8DwNUt6+2P2y4EYC2AHQB6fAuc9oN6X5zitNPE1svOtvFzjOKbb8TW27wZGDRIe51QCLjlFumzNYved0LmjTeAiQq/xW3bgEsuAV5+Gbgo/nfnAiefLH0fv/tOfZ2CAuDUU8X2l50N7N8fe+33x3+RWzl2fRdCIWDtWmDHDqBHD2DoUOBf/2r5/7TT3L8/RCGP2yTy+3Jea6lTX19PAGjt2rUxy2fNmkVDhgxR3KZt27ZUEfcE96c//Ym6deumuH5ZWRlBGkG5cePGjRs3binetm7dqqsvkmq56dq1K/x+P3bu3BmzfOfOnejRo4fiNj169DC0/p133omZM2dG/m9ubsbevXuRm5sLn89n8QyssW/fPhQVFWHr1q3Izs5Oal9SEb5+1uDrZw2+ftbg62ed1nYNiQg//fQTevbsqbtuUsVNZmYmBg8ejNWrV2Ps2LEAJPGxevVqTJs2TXGbYcOGYfXq1SgpKYkse+eddzBs2DDF9bOyspCVlRWzrEuXLnZ03zays7NbxRfTKfj6WYOvnzX4+lmDr591WtM17Ny5s9B6SRU3ADBz5kxcffXVOOWUUzBkyBDMmzcP+/fvxzXXXAMAuOqqq1BQUICHH34YADB9+nScddZZePzxx3HBBRdg6dKl+M9//oPnnnsumafBMAzDMIxHSLq4GT9+PHbt2oV77rkHO3bswC9+8QusXLkyEjS8ZcsWZGRkRNY/7bTTUFFRgdLSUsyePRvHHnssXnvtNZx44onJOgWGYRiGYTxE0sUNAEybNk3VDVVbW5uw7He/+x1+97vfOdwr58nKykJZWVmC24wRg6+fNfj6WYOvnzX4+lmHr6E6PiIrOYsMwzAMwzDeIkN/FYZhGIZhmNSBxQ3DMAzDMGkFixuGYRiGYdIKFjcMwzAMw6QVLG4c5k9/+hP69OmDdu3aYejQofj3v/+tum51dTVOOeUUdOnSBUcccQR+8Ytf4OWXX3axt97DyPWLZunSpfD5fJHikK0VI9dv0aJF8Pl8Ma1du3Yu9tZ7GP3+/fjjj5g6dSry8/ORlZWF4447DitWrHCpt97DyPUbMWJEwvfP5/PhggsucLHH3sLo92/evHno168f2rdvj6KiIsyYMQOHDh1yqbceQ2QOKMYcS5cupczMTHrxxRfp888/p8mTJ1OXLl1o586diusHAgGqrq6m9evX06ZNm2jevHnk9/tp5cqVLvfcGxi9fjJ1dXVUUFBAw4cPpzFjxrjTWQ9i9PotXLiQsrOzafv27ZG2Y8cOl3vtHYxev8bGRjrllFPoN7/5Df3zn/+kuro6qq2tpXXr1rncc29g9Prt2bMn5rv32Wefkd/vp4ULF7rbcY9g9Pr99a9/paysLPrrX/9KdXV1tGrVKsrPz6cZM2a43HNvwOLGQYYMGUJTp06N/B8Khahnz5708MMPC+/jl7/8JZWWljrRPc9j5voFg0E67bTT6IUXXqCrr766VYsbo9dv4cKF1LlzZ5d6532MXr9nnnmGjjrqKGpqanKri57G6v1v7ty51KlTJ/r555+d6qKnMXr9pk6dSmeffXbMspkzZ9Lpp5/uaD+9CrulHKKpqQkffvghRo0aFVmWkZGBUaNG4b333tPdnoiwevVqbNy4EWeeeaaTXfUkZq/ffffdh27duuG6665zo5uexez1+/nnn9G7d28UFRVhzJgx+Pzzz93orucwc/3eeOMNDBs2DFOnTkX37t1x4okn4qGHHkIoFHKr257B6v0PABYsWIDLLrsMRxxxhFPd9Cxmrt9pp52GDz/8MOK6+vrrr7FixQr85je/caXPXsMTFYrTkd27dyMUCkWmkZDp3r07vvjiC9XtGhoaUFBQgMbGRvj9fsyfPx/nnnuu0931HGau3z//+U8sWLAA69atc6GH3sbM9evXrx9efPFFDBw4EA0NDZgzZw5OO+00fP755ygsLHSj257BzPX7+uuv8b//+7+44oorsGLFCmzatAk333wzDh8+jLKyMje67RnM3v9k/v3vf+Ozzz7DggULnOqipzFz/S6//HLs3r0bZ5xxBogIwWAQN954I2bPnu1Glz0HixuP0alTJ6xbtw4///wzVq9ejZkzZ+Koo47CiBEjkt01T/PTTz9h4sSJeP7559G1a9dkdyclGTZsGIYNGxb5/7TTTkP//v3x5z//Gffff38Se5YaNDc3o1u3bnjuuefg9/sxePBg1NfX47HHHmt14sYqCxYswEknnYQhQ4YkuyspQ21tLR566CHMnz8fQ4cOxaZNmzB9+nTcf//9uPvuu5PdPddhceMQXbt2hd/vx86dO2OW79y5Ez169FDdLiMjA8cccwwA4Be/+AU2bNiAhx9+uNWJG6PXb/Pmzfjmm29w4YUXRpY1NzcDANq0aYONGzfi6KOPdrbTHsLs9y+atm3b4pe//CU2bdrkRBc9jZnrl5+fj7Zt28Lv90eW9e/fHzt27EBTUxMyMzMd7bOXsPL9279/P5YuXYr77rvPyS56GjPX7+6778bEiRNx/fXXAwBOOukk7N+/H1OmTMFdd90VMwF1a6B1na2LZGZmYvDgwVi9enVkWXNzM1avXh3zdKxHc3MzGhsbneiipzF6/Y4//nh8+umnWLduXaRddNFFGDlyJNatW4eioiI3u5907Pj+hUIhfPrpp8jPz3eqm57FzPU7/fTTsWnTpoioBoAvv/wS+fn5rUrYANa+f8uWLUNjYyOuvPJKp7vpWcxcvwMHDiQIGFloU2ucQjLJAc1pzdKlSykrK4sWLVpE69evpylTplCXLl0i6bUTJ06kO+64I7L+Qw89RG+//TZt3ryZ1q9fT3PmzKE2bdrQ888/n6xTSCpGr188rT1byuj1Ky8vp1WrVtHmzZvpww8/pMsuu4zatWtHn3/+ebJOIakYvX5btmyhTp060bRp02jjxo3097//nbp160YPPPBAsk4hqZj9/Z5xxhk0fvx4t7vrOYxev7KyMurUqRMtWbKEvv76a3r77bfp6KOPpksvvTRZp5BU2C3lIOPHj8euXbtwzz33YMeOHfjFL36BlStXRoLEtmzZEqO09+/fj5tvvhnbtm1D+/btcfzxx2Px4sUYP358sk4hqRi9fkwsRq/fDz/8gMmTJ2PHjh048sgjMXjwYKxduxYDBgxI1ikkFaPXr6ioCKtWrcKMGTMwcOBAFBQUYPr06bj99tuTdQpJxczvd+PGjfjnP/+Jt99+Oxld9hRGr19paSl8Ph9KS0tRX1+PvLw8XHjhhXjwwQeTdQpJxUfUGu1VDMMwDMOkK/zYyzAMwzBMWsHihmEYhmGYtILFDcMwDMMwaQWLG4ZhGIZh0goWNwzDMAzDpBUsbhiGYRiGSStY3DAMwzAMk1awuGEYhmEYJq1gccMwjOeZNGkSxo4dG7Ns+fLlaNeuHR5//PHkdIphGM/C0y8wDJNyvPDCC5g6dSqeffZZXHPNNcnuDsMwHoMtNwzDpBSPPvoobrnlFixduhTXXHMNdu3ahR49euChhx6KrLN27VpkZmZi9erV+Oabb5CRkYH//Oc/MfuZN28eevfuHTOLN8Mw6QFbbhiGSRluv/12zJ8/H3//+99xzjnnAADy8vLw4osvYuzYsTjvvPPQr18/TJw4EdOmTYusM2rUKCxcuBCnnHJKZF8LFy7EpEmTePJVhklDeOJMhmE8z6RJk7BkyRI0NTVh9erVOPvssxPWmTp1KmpqanDKKafg008/xQcffICsrCwAQGVlJW688UZs374dWVlZ+Oijj3DKKafg66+/Rp8+fVw+G4ZhnIYfWRiGSQkGDhyIPn36oKysDD///HPC+3PmzEEwGMSyZcvw17/+NSJsAGDs2LHw+/149dVXAQCLFi3CyJEjWdgwTJrC4oZhmJSgoKAAtbW1qK+vx/nnn4+ffvop5v3Nmzfju+++Q3NzM7755puY9zIzM3HVVVdh4cKFaGpqQkVFBa699loXe88wjJuwuGEYJmXo3bs3/u///g87duyIEThNTU248sorMX78eNx///24/vrr8f3338dse/3116Ompgbz589HMBhEcXFxMk6BYRgXYHHDMExKUVRUhNraWnz//fcYPXo09u3bh7vuugsNDQ344x//iNtvvx3HHXdcgmWmf//++NWvfoXbb78dEyZMQPv27ZN0BgzDOA2LG4ZhUo7CwkLU1tZi9+7dGD16NObMmYOXX34Z2dnZyMjIwMsvv4w1a9bgmWeeidnuuuuuQ1NTE7ukGCbN4WwphmFaDffffz+WLVuG//73v8nuCsMwDsKWG4Zh0p6ff/4Zn332GZ5++mnccsstye4OwzAOw+KGYZi0Z9q0aRg8eDBGjBjBLimGaQWwW4phGIZhmLSCLTcMwzAMw6QVLG4YhmEYhkkrWNwwDMMwDJNWsLhhGIZhGCatYHHDMAzDMExaweKGYRiGYZi0gsUNwzAMwzBpBYsbhmEYhmHSChY3DMMwDMOkFf8Pl0uWi+JZO+oAAAAASUVORK5CYII=",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# for some n number of points: default to 1000\n",
+ "model1.y_scrambling(n=1000)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "2f0a391d",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "RMSE : 0.2508516645820539\n",
+ "RMSE External : 0.3291162069672103\n",
+ "R2 : 0.7932755997633875\n",
+ "Q2 : 0.7099699197171891\n",
+ "Q2F1 : 0.7138880300214392\n",
+ "Q2F2 : 0.7106827057393145\n",
+ "Q2F3 : 0.9978028024221\n",
+ "CCC : 0.9007449089766993\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{'RMSE': 0.2508516645820539,\n",
+ " 'RMSE External': 0.3291162069672103,\n",
+ " 'R2': 0.7932755997633875,\n",
+ " 'Q2': 0.7099699197171891,\n",
+ " 'Q2F1': 0.7138880300214392,\n",
+ " 'Q2F2': 0.7106827057393145,\n",
+ " 'Q2F3': 0.9978028024221,\n",
+ " 'CCC': 0.9007449089766993}"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model1.scores(verbose=True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "972d748f",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Model features: ['RDF070v', 'X5Av']\n",
+ "Coefficients: [ -1.45342979 -96.40117135]\n",
+ "Intercept: -0.07684397375001017\n",
+ "RMSE: 0.250852\n",
+ "R^2: 0.793276\n"
+ ]
+ }
+ ],
+ "source": [
+ "model1.mlr()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "id": "b29d4de4",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "model1.p_value_plot()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "id": "5ecdce6c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAGwCAYAAABIC3rIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA5Q0lEQVR4nO3de1hU9d7//9eAMCg6g3gA2ZLSTans1DyUTh7KJKmNnaSdliWZ1qWhppanb21SO+ht2zxUSmVF7lszO5d4iDAPKWmx09SU2xJTU6A7hBEPiLB+f3ixfk64zVFg0PV8XNe6Lubz+cxnvRdewMs1n7WWzTAMQwAAABbm5+sCAAAAfI1ABAAALI9ABAAALI9ABAAALI9ABAAALI9ABAAALI9ABAAALK+Orwu4FJSXl+vgwYNq0KCBbDabr8sBAADnwTAMHTlyRBEREfLzO/c5IALReTh48KAiIyN9XQYAALgA+/fvV/Pmzc85hkB0Hho0aCDp9DfU4XD4uBoAAHA+3G63IiMjzb/j50IgOg8VH5M5HA4CEQAAl5jzWe7ComoAAGB5BCIAAGB5BCIAAGB5BCIAAGB5BCIAAGB5BCIAAGB5BCIAAGB5BCIAAGB5BCIAAGB5BCIAAGB5BCIAAGB5BCIAAGB5BCIAAGB5BCIAAGB5BCIAAGB5dXxdAABYQcuJab4uAajV9k6P9+n+OUMEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsz+eB6Ndff9UDDzygRo0aqW7dumrbtq2+++47s98wDCUnJ6tZs2aqW7euYmNjtXv3bo85CgoKNHDgQDkcDoWEhGjIkCEqLi72GPPDDz+oR48eCgoKUmRkpGbMmFEjxwcAAGo/nwaiw4cPq1u3bgoICNCKFSv0448/aubMmWrYsKE5ZsaMGZo7d65SUlK0adMmBQcHKy4uTidOnDDHDBw4UDt27FB6erqWLVumdevW6dFHHzX73W63+vTpoxYtWigrK0svvviiJk+erNdff71GjxcAANRONsMwDF/tfOLEidqwYYPWr19/1n7DMBQREaEnnnhCTz75pCSpqKhIYWFhSk1N1YABA7Rz507FxMTo22+/VefOnSVJK1eu1N/+9jcdOHBAERERmj9/vp566inl5uYqMDDQ3Pcnn3yiXbt2VdpvSUmJSkpKzNdut1uRkZEqKiqSw+Go6m8DAAtoOTHN1yUAtdre6fFVPqfb7ZbT6Tyvv98+PUP02WefqXPnzvr73/+upk2bqkOHDnrjjTfM/pycHOXm5io2NtZsczqd6tKlizIzMyVJmZmZCgkJMcOQJMXGxsrPz0+bNm0yx/Ts2dMMQ5IUFxen7OxsHT58uFJd06ZNk9PpNLfIyMgqP3YAAFB7+DQQ7dmzR/Pnz9dVV12lVatWafjw4Ro1apTeeecdSVJubq4kKSwszON9YWFhZl9ubq6aNm3q0V+nTh2FhoZ6jDnbHGfu40yTJk1SUVGRue3fv78KjhYAANRWdXy58/LycnXu3FkvvPCCJKlDhw7avn27UlJSlJiY6LO67Ha77Ha7z/YPAABqlk/PEDVr1kwxMTEebW3atNG+ffskSeHh4ZKkvLw8jzF5eXlmX3h4uPLz8z36T506pYKCAo8xZ5vjzH0AAADr8mkg6tatm7Kzsz3a/vd//1ctWrSQJEVFRSk8PFwZGRlmv9vt1qZNm+RyuSRJLpdLhYWFysrKMsesXr1a5eXl6tKlizlm3bp1Ki0tNcekp6erVatWHle0AQAAa/JpIBozZoy++eYbvfDCC/rpp5+0ePFivf7660pKSpIk2Ww2jR49Ws8995w+++wzbdu2TYMGDVJERITuuusuSafPKN1666165JFHtHnzZm3YsEEjRozQgAEDFBERIUm6//77FRgYqCFDhmjHjh167733NGfOHI0dO9ZXhw4AAGoRn64huu666/Txxx9r0qRJmjp1qqKiojR79mwNHDjQHDN+/HgdPXpUjz76qAoLC9W9e3etXLlSQUFB5phFixZpxIgR6t27t/z8/JSQkKC5c+ea/U6nU1988YWSkpLUqVMnNW7cWMnJyR73KgIAANbl0/sQXSq8uY8BAJwN9yECzs3S9yECAACoDQhEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8nwaiCZPniybzeaxtW7d2uw/ceKEkpKS1KhRI9WvX18JCQnKy8vzmGPfvn2Kj49XvXr11LRpU40bN06nTp3yGLNmzRp17NhRdrtd0dHRSk1NrYnDAwAAlwifnyH661//qkOHDpnb119/bfaNGTNGn3/+ud5//32tXbtWBw8eVL9+/cz+srIyxcfH6+TJk9q4caPeeecdpaamKjk52RyTk5Oj+Ph49erVS1u2bNHo0aM1dOhQrVq1qkaPEwAA1F51fF5AnToKDw+v1F5UVKQ333xTixcv1s033yxJevvtt9WmTRt988036tq1q7744gv9+OOP+vLLLxUWFqZrr71Wzz77rCZMmKDJkycrMDBQKSkpioqK0syZMyVJbdq00ddff61Zs2YpLi7urDWVlJSopKTEfO12u6vhyAEAQG3h8zNEu3fvVkREhK688koNHDhQ+/btkyRlZWWptLRUsbGx5tjWrVvriiuuUGZmpiQpMzNTbdu2VVhYmDkmLi5ObrdbO3bsMMecOUfFmIo5zmbatGlyOp3mFhkZWWXHCwAAah+fBqIuXbooNTVVK1eu1Pz585WTk6MePXroyJEjys3NVWBgoEJCQjzeExYWptzcXElSbm6uRxiq6K/oO9cYt9ut48ePn7WuSZMmqaioyNz2799fFYcLAABqKZ9+ZHbbbbeZX7dr105dunRRixYttHTpUtWtW9dnddntdtntdp/tHwAA1Cyff2R2ppCQEF199dX66aefFB4erpMnT6qwsNBjTF5enrnmKDw8vNJVZxWv/2yMw+HwaegCAAC1R60KRMXFxfr555/VrFkzderUSQEBAcrIyDD7s7OztW/fPrlcLkmSy+XStm3blJ+fb45JT0+Xw+FQTEyMOebMOSrGVMwBAADg00D05JNPau3atdq7d682btyou+++W/7+/rrvvvvkdDo1ZMgQjR07Vl999ZWysrI0ePBguVwude3aVZLUp08fxcTE6MEHH9TWrVu1atUqPf3000pKSjI/8ho2bJj27Nmj8ePHa9euXZo3b56WLl2qMWPG+PLQAQBALeLTNUQHDhzQfffdp99//11NmjRR9+7d9c0336hJkyaSpFmzZsnPz08JCQkqKSlRXFyc5s2bZ77f399fy5Yt0/Dhw+VyuRQcHKzExERNnTrVHBMVFaW0tDSNGTNGc+bMUfPmzbVgwYL/eMk9AACwHpthGIavi6jt3G63nE6nioqK5HA4fF0OgEtQy4lpvi4BqNX2To+v8jm9+ftdq9YQAQAA+AKBCAAAWB6BCAAAWB6BCAAAWB6BCAAAWB6BCAAAWB6BCAAAWN4FBaL169frgQcekMvl0q+//ipJ+te//qWvv/66SosDAACoCV4Hog8//FBxcXGqW7euvv/+e5WUlEiSioqK9MILL1R5gQAAANXN60D03HPPKSUlRW+88YYCAgLM9m7duunf//53lRYHAABQE7wORNnZ2erZs2eldqfTqcLCwqqoCQAAoEZ5HYjCw8P1008/VWr/+uuvdeWVV1ZJUQAAADXJ60D0yCOP6PHHH9emTZtks9l08OBBLVq0SE8++aSGDx9eHTUCAABUqzrevmHixIkqLy9X7969dezYMfXs2VN2u11PPvmkRo4cWR01AgAAVCuvA5HNZtNTTz2lcePG6aefflJxcbFiYmJUv3796qgPAACg2nkdiIqKilRWVqbQ0FDFxMSY7QUFBapTp44cDkeVFggAAFDdvF5DNGDAAC1ZsqRS+9KlSzVgwIAqKQoAAKAmeR2INm3apF69elVqv+mmm7Rp06YqKQoAAKAmeR2ISkpKdOrUqUrtpaWlOn78eJUUBQAAUJO8DkTXX3+9Xn/99UrtKSkp6tSpU5UUBQAAUJO8XlT93HPPKTY2Vlu3blXv3r0lSRkZGfr222/1xRdfVHmBAAAA1c3rM0TdunVTZmamIiMjtXTpUn3++eeKjo7WDz/8oB49elRHjQAAANXK6zNEknTttddq0aJFVV0LAACAT1xQICovL9dPP/2k/Px8lZeXe/Sd7cGvAAAAtZnXgeibb77R/fffr19++UWGYXj02Ww2lZWVVVlxAAAANcHrQDRs2DB17txZaWlpatasmWw2W3XUBQAAUGO8DkS7d+/WBx98oOjo6OqoBwAAoMZ5fZVZly5d9NNPP1VHLQAAAD7h9RmikSNH6oknnlBubq7atm2rgIAAj/527dpVWXEAAAA1wetAlJCQIEl6+OGHzTabzSbDMFhUDQAALkleB6KcnJzqqAMAAMBnvA5ELVq0qI46AAAAfOaCbswoST/++KP27dunkydPerTfcccdF10UAABATfI6EO3Zs0d33323tm3bZq4dkmTej4g1RAAA4FLj9WX3jz/+uKKiopSfn6969eppx44dWrdunTp37qw1a9ZUQ4kAAADVy+szRJmZmVq9erUaN24sPz8/+fn5qXv37po2bZpGjRql77//vjrqBAAAqDZenyEqKytTgwYNJEmNGzfWwYMHJZ1ebJ2dnV211QEAANQAr88QXXPNNdq6dauioqLUpUsXzZgxQ4GBgXr99dd15ZVXVkeNAAAA1crrQPT000/r6NGjkqSpU6eqb9++6tGjhxo1aqQlS5ZUeYEAAADVzetAFBcXZ34dHR2tXbt2qaCgQA0bNjSvNAMAALiUeL2G6OGHH9aRI0c82kJDQ3Xs2DGPx3kAAABcKrwORO+8846OHz9eqf348eNauHBhlRQFAABQk847ELndbhUVFckwDB05ckRut9vcDh8+rOXLl6tp06YXXMj06dNls9k0evRos+3EiRNKSkpSo0aNVL9+fSUkJCgvL8/jffv27VN8fLzq1aunpk2baty4cTp16pTHmDVr1qhjx46y2+2Kjo5WamrqBdcJAAAuP+e9higkJEQ2m002m01XX311pX6bzaYpU6ZcUBHffvutXnvtNbVr186jfcyYMUpLS9P7778vp9OpESNGqF+/ftqwYYOk07cAiI+PV3h4uDZu3KhDhw5p0KBBCggI0AsvvCDp9MNo4+PjNWzYMC1atEgZGRkaOnSomjVr5rEeCgAAWJfNqHj2xp9Yu3atDMPQzTffrA8//FChoaFmX2BgoFq0aKGIiAivCyguLlbHjh01b948Pffcc7r22ms1e/ZsFRUVqUmTJlq8eLHuueceSdKuXbvUpk0bZWZmqmvXrlqxYoX69u2rgwcPKiwsTJKUkpKiCRMm6LffflNgYKAmTJigtLQ0bd++3dzngAEDVFhYqJUrV561ppKSEpWUlJiv3W63IiMjVVRUJIfD4fUxAkDLiWm+LgGo1fZOj6/yOd1ut5xO53n9/T7vj8xuvPFGde/eXYmJiercubNuvPFGc3O5XBcUhiQpKSlJ8fHxio2N9WjPyspSaWmpR3vr1q11xRVXKDMzU9Lpu2a3bdvWDEPS6avg3G63duzYYY7549xxcXHmHGczbdo0OZ1Oc4uMjLygYwMAAJcGrxZV16lTRx988EGVPcB1yZIl+ve//61p06ZV6svNzVVgYKBCQkI82sPCwpSbm2uOOTMMVfRX9J1rjNvtPuvicEmaNGmSioqKzG3//v0XdHwAAODS4PV9iG6++WatXbtWLVu2vKgd79+/X48//rjS09MVFBR0UXNVNbvdLrvd7usyAABADfE6EN12222aOHGitm3bpk6dOik4ONij/4477jivebKyspSfn6+OHTuabWVlZVq3bp1eeeUVrVq1SidPnlRhYaHHWaK8vDyFh4dLksLDw7V582aPeSuuQjtzzB+vTMvLy5PD4VDdunXP76ABAMBlzetA9Nhjj0mSXnrppUp9NpvtvD9O6927t7Zt2+bRNnjwYLVu3VoTJkxQZGSkAgIClJGRoYSEBElSdna29u3bJ5fLJUlyuVx6/vnnlZ+fb17yn56eLofDoZiYGHPM8uXLPfaTnp5uzgEAAOB1ICovL6+SHTdo0EDXXHONR1twcLAaNWpktg8ZMkRjx45VaGioHA6HRo4cKZfLpa5du0qS+vTpo5iYGD344IOaMWOGcnNz9fTTTyspKcn8yGvYsGF65ZVXNH78eD388MNavXq1li5dqrQ0rvgAAACneR2IatKsWbPk5+enhIQElZSUKC4uTvPmzTP7/f39tWzZMg0fPlwul0vBwcFKTEzU1KlTzTFRUVFKS0vTmDFjNGfOHDVv3lwLFizgHkQAAMB03vchOtPatWv1z3/+Uzt37pQkxcTEaNy4cerRo0eVF1gbeHMfAwA4G+5DBJzbJXMfogr/8z//o9jYWNWrV0+jRo3SqFGjVLduXfXu3VuLFy++4KIBAAB8xeszRG3atNGjjz6qMWPGeLS/9NJLeuONN8yzRpcTzhABuFicIQLO7ZI7Q7Rnzx7dfvvtldrvuOMO5eTkeDsdAACAz3kdiCIjI5WRkVGp/csvv+QRFwAA4JLk9VVmTzzxhEaNGqUtW7bohhtukCRt2LBBqampmjNnTpUXCAAAUN28DkTDhw9XeHi4Zs6cqaVLl0o6va7ovffe05133lnlBQIAAFS3C7oP0d1336277767qmsBAADwiQu+MeN3333ncR+iTp06VVlRAAAANcnrQHTgwAHdd9992rBhg/nQ1cLCQt1www1asmSJmjdvXtU1AgAAVCuvrzIbOnSoSktLtXPnThUUFKigoEA7d+5UeXm5hg4dWh01AgAAVCuvzxCtXbtWGzduVKtWrcy2Vq1a6eWXX75sH90BAAAubxd0H6LS0tJK7WVlZYqIiKiSogAAAGqS14HoxRdf1MiRI/Xdd9+Zbd99950ef/xx/fOf/6zS4gAAAGqC188ya9iwoY4dO6ZTp06pTp3Tn7hVfB0cHOwxtqCgoOoq9SGeZQbgYvEsM+DcfP0sM6/XEM2ePftC6wIAAKiVvA5EiYmJ1VEHAACAz1zwjRnz8/OVn5+v8vJyj/Z27dpddFEAAAA1yetAlJWVpcTERO3cuVN/XH5ks9lUVlZWZcUBAADUBK8D0cMPP6yrr75ab775psLCwmSz2aqjLgAAgBrjdSDas2ePPvzwQ0VHR1dHPQAAADXO6/sQ9e7dW1u3bq2OWgAAAHzC6zNECxYsUGJiorZv365rrrlGAQEBHv133HFHlRUHAABQE7wORJmZmdqwYYNWrFhRqY9F1QAA4FLk9UdmI0eO1AMPPKBDhw6pvLzcYyMMAQCAS5HXgej333/XmDFjFBYWVh31AAAA1DivA1G/fv301VdfVUctAAAAPuH1GqKrr75akyZN0tdff622bdtWWlQ9atSoKisOAACgJnj9tPuoqKj/PJnNpj179lx0UbUNT7sHcLF42j1wbpfc0+5zcnIuuDAAAIDayOs1RAAAAJeb8zpDNHbsWD377LMKDg7W2LFjzzn2pZdeqpLCAAAAasp5BaLvv/9epaWl5tf/CQ96BQAAl6LzCkRnXmbPJfcAAOBywxoiAABgeQQiAABgeQQiAABgeQQiAABgeQQiAABgeRcUiP71r3+pW7duioiI0C+//CJJmj17tj799NMqLQ4AAKAmeB2I5s+fr7Fjx+pvf/ubCgsLVVZWJkkKCQnR7Nmzq7o+AACAaud1IHr55Zf1xhtv6KmnnpK/v7/Z3rlzZ23btq1KiwMAAKgJXgeinJwcdejQoVK73W7X0aNHq6QoAACAmuR1IIqKitKWLVsqta9cuVJt2rTxaq758+erXbt2cjgccjgccrlcWrFihdl/4sQJJSUlqVGjRqpfv74SEhKUl5fnMce+ffsUHx+vevXqqWnTpho3bpxOnTrlMWbNmjXq2LGj7Ha7oqOjlZqa6lWdAADg8nZej+4409ixY5WUlKQTJ07IMAxt3rxZ7777rqZNm6YFCxZ4NVfz5s01ffp0XXXVVTIMQ++8847uvPNOff/99/rrX/+qMWPGKC0tTe+//76cTqdGjBihfv36acOGDZKksrIyxcfHKzw8XBs3btShQ4c0aNAgBQQE6IUXXpB0+oxWfHy8hg0bpkWLFikjI0NDhw5Vs2bNFBcX5+3hAwCAy5DNMAzD2zctWrRIkydP1s8//yxJioiI0JQpUzRkyJCLLig0NFQvvvii7rnnHjVp0kSLFy/WPffcI0natWuX2rRpo8zMTHXt2lUrVqxQ3759dfDgQYWFhUmSUlJSNGHCBP32228KDAzUhAkTlJaWpu3bt5v7GDBggAoLC7Vy5crzqsntdsvpdKqoqEgOh+OijxGA9bScmObrEoBabe/0+Cqf05u/3159ZHbq1CktXLhQsbGx2r17t4qLi5Wbm6sDBw5cdBgqKyvTkiVLdPToUblcLmVlZam0tFSxsbHmmNatW+uKK65QZmamJCkzM1Nt27Y1w5AkxcXFye12a8eOHeaYM+eoGFMxx9mUlJTI7XZ7bAAA4PLlVSCqU6eOhg0bphMnTkiSuW7nYmzbtk3169eX3W7XsGHD9PHHHysmJka5ubkKDAxUSEiIx/iwsDDl5uZKknJzcz3CUEV/Rd+5xrjdbh0/fvysNU2bNk1Op9PcIiMjL+oYAQBA7eb1ourrr79e33//fZUV0KpVK23ZskWbNm3S8OHDlZiYqB9//LHK5r8QkyZNUlFRkbnt37/fp/UAAIDq5fWi6scee0xPPPGEDhw4oE6dOik4ONijv127dl7NFxgYqOjoaElSp06d9O2332rOnDnq37+/Tp48qcLCQo+zRHl5eQoPD5ckhYeHa/PmzR7zVVyFduaYP16ZlpeXJ4fDobp16561JrvdLrvd7tVxAACAS5fXgWjAgAGSpFGjRpltNptNhmHIZrOZd66+UOXl5SopKVGnTp0UEBCgjIwMJSQkSJKys7O1b98+uVwuSZLL5dLzzz+v/Px886O79PR0ORwOxcTEmGOWL1/usY/09HRzDgAAAK8DUU5OTpXtfNKkSbrtttt0xRVX6MiRI1q8eLHWrFmjVatWyel0asiQIRo7dqxCQ0PlcDg0cuRIuVwude3aVZLUp08fxcTE6MEHH9SMGTOUm5urp59+WklJSeYZnmHDhumVV17R+PHj9fDDD2v16tVaunSp0tK44gMAAJzmdSBq0aJFle08Pz9fgwYN0qFDh+R0OtWuXTutWrVKt9xyiyRp1qxZ8vPzU0JCgkpKShQXF6d58+aZ7/f399eyZcs0fPhwuVwuBQcHKzExUVOnTjXHREVFKS0tTWPGjNGcOXPUvHlzLViwgHsQAQAAk9f3IVq4cOE5+wcNGnRRBdVG3IcIwMXiPkTAufn6PkRenyF6/PHHPV6Xlpbq2LFjCgwMVL169S7LQAQAAC5vXl92f/jwYY+tuLhY2dnZ6t69u959993qqBEAAKBaeR2Izuaqq67S9OnTK509AgAAuBRUSSCSTt/F+uDBg1U1HQAAQI3xeg3RZ5995vHaMAwdOnRIr7zyirp161ZlhQEAANQUrwPRXXfd5fHaZrOpSZMmuvnmmzVz5syqqgsAAKDGeB2IysvLq6MOAAAAn/F6DdHUqVN17NixSu3Hjx/3uCEiAADApcLrQDRlyhQVFxdXaj927JimTJlSJUUBAADUJK8DUcVDXP9o69atCg0NrZKiAAAAatJ5ryFq2LChbDabbDabrr76ao9QVFZWpuLiYg0bNqxaigQAAKhO5x2IZs+eLcMw9PDDD2vKlClyOp1mX2BgoFq2bCmXy1UtRQIAAFSn8w5EiYmJkk4/Pf6GG25QQEBAtRUFAABQk7y+7P7GG280vz5x4oROnjzp0c/T4AEAwKXG60XVx44d04gRI9S0aVMFBwerYcOGHhsAAMClxutANG7cOK1evVrz58+X3W7XggULNGXKFEVERGjhwoXVUSMAAEC18vojs88//1wLFy7UTTfdpMGDB6tHjx6Kjo5WixYttGjRIg0cOLA66gQAAKg2Xp8hKigo0JVXXinp9HqhgoICSVL37t21bt26qq0OAACgBngdiK688krl5ORIklq3bq2lS5dKOn3mKCQkpEqLAwAAqAleB6LBgwdr69atkqSJEyfq1VdfVVBQkMaMGaNx48ZVeYEAAADVzes1RGPGjDG/jo2N1a5du5SVlaXo6Gi1a9euSosDAACoCV4HojOdOHFCLVq0UIsWLaqqHgAAgBrn9UdmZWVlevbZZ/WXv/xF9evX1549eyRJ//jHP/Tmm29WeYEAAADVzetA9Pzzzys1NVUzZsxQYGCg2X7NNddowYIFVVocAABATfA6EC1cuFCvv/66Bg4cKH9/f7O9ffv22rVrV5UWBwAAUBO8DkS//vqroqOjK7WXl5ertLS0SooCAACoSV4HopiYGK1fv75S+wcffKAOHTpUSVEAAAA1yeurzJKTk5WYmKhff/1V5eXl+uijj5Sdna2FCxdq2bJl1VEjAABAtfL6DNGdd96pzz//XF9++aWCg4OVnJysnTt36vPPP9ctt9xSHTUCAABUq/M+Q7Rnzx5FRUXJZrOpR48eSk9Pr866AAAAasx5nyG66qqr9Ntvv5mv+/fvr7y8vGopCgAAoCaddyAyDMPj9fLly3X06NEqLwgAAKCmeb2GCAAA4HJz3oHIZrPJZrNVagMAALjUnfeiasMw9NBDD8lut0s6/WDXYcOGKTg42GPcRx99VLUVAgAAVLPzDkSJiYkerx944IEqLwYAAMAXzjsQvf3229VZBwAAgM+wqBoAAFgegQgAAFgegQgAAFgegQgAAFgegQgAAFieTwPRtGnTdN1116lBgwZq2rSp7rrrLmVnZ3uMOXHihJKSktSoUSPVr19fCQkJlZ6htm/fPsXHx6tevXpq2rSpxo0bp1OnTnmMWbNmjTp27Ci73a7o6GilpqZW9+EBAIBLhE8D0dq1a5WUlKRvvvlG6enpKi0tVZ8+fTyekTZmzBh9/vnnev/997V27VodPHhQ/fr1M/vLysoUHx+vkydPauPGjXrnnXeUmpqq5ORkc0xOTo7i4+PVq1cvbdmyRaNHj9bQoUO1atWqGj1eAABQO9mMPz611Yd+++03NW3aVGvXrlXPnj1VVFSkJk2aaPHixbrnnnskSbt27VKbNm2UmZmprl27asWKFerbt68OHjyosLAwSVJKSoomTJig3377TYGBgZowYYLS0tK0fft2c18DBgxQYWGhVq5c+ad1ud1uOZ1OFRUVyeFwVM/BA7istZyY5usSgFpt7/T4Kp/Tm7/ftWoNUVFRkSQpNDRUkpSVlaXS0lLFxsaaY1q3bq0rrrhCmZmZkqTMzEy1bdvWDEOSFBcXJ7fbrR07dphjzpyjYkzFHH9UUlIit9vtsQEAgMtXrQlE5eXlGj16tLp166ZrrrlGkpSbm6vAwECFhIR4jA0LC1Nubq455swwVNFf0XeuMW63W8ePH69Uy7Rp0+R0Os0tMjKySo4RAADUTrUmECUlJWn79u1asmSJr0vRpEmTVFRUZG779+/3dUkAAKAanfezzKrTiBEjtGzZMq1bt07Nmzc328PDw3Xy5EkVFhZ6nCXKy8tTeHi4OWbz5s0e81VchXbmmD9emZaXlyeHw6G6detWqsdut8tut1fJsQEAgNrPp2eIDMPQiBEj9PHHH2v16tWKiory6O/UqZMCAgKUkZFhtmVnZ2vfvn1yuVySJJfLpW3btik/P98ck56eLofDoZiYGHPMmXNUjKmYAwAAWJtPzxAlJSVp8eLF+vTTT9WgQQNzzY/T6VTdunXldDo1ZMgQjR07VqGhoXI4HBo5cqRcLpe6du0qSerTp49iYmL04IMPasaMGcrNzdXTTz+tpKQk8yzPsGHD9Morr2j8+PF6+OGHtXr1ai1dulRpaVz1AQAAfHyGaP78+SoqKtJNN92kZs2amdt7771njpk1a5b69u2rhIQE9ezZU+Hh4froo4/Mfn9/fy1btkz+/v5yuVx64IEHNGjQIE2dOtUcExUVpbS0NKWnp6t9+/aaOXOmFixYoLi4uBo9XgAAUDvVqvsQ1VbchwjAxeI+RMC5cR8iAAAAHyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAy/NpIFq3bp1uv/12RUREyGaz6ZNPPvHoNwxDycnJatasmerWravY2Fjt3r3bY0xBQYEGDhwoh8OhkJAQDRkyRMXFxR5jfvjhB/Xo0UNBQUGKjIzUjBkzqvvQAADAJcSngejo0aNq3769Xn311bP2z5gxQ3PnzlVKSoo2bdqk4OBgxcXF6cSJE+aYgQMHaseOHUpPT9eyZcu0bt06Pfroo2a/2+1Wnz591KJFC2VlZenFF1/U5MmT9frrr1f78QEAgEuDzTAMw9dFSJLNZtPHH3+su+66S9Lps0MRERF64okn9OSTT0qSioqKFBYWptTUVA0YMEA7d+5UTEyMvv32W3Xu3FmStHLlSv3tb3/TgQMHFBERofnz5+upp55Sbm6uAgMDJUkTJ07UJ598ol27dp1XbW63W06nU0VFRXI4HFV/8AAuey0npvm6BKBW2zs9vsrn9Obvd61dQ5STk6Pc3FzFxsaabU6nU126dFFmZqYkKTMzUyEhIWYYkqTY2Fj5+flp06ZN5piePXuaYUiS4uLilJ2drcOHD5913yUlJXK73R4bAAC4fNXaQJSbmytJCgsL82gPCwsz+3Jzc9W0aVOP/jp16ig0NNRjzNnmOHMffzRt2jQ5nU5zi4yMvPgDAgAAtVatDUS+NGnSJBUVFZnb/v37fV0SAACoRrU2EIWHh0uS8vLyPNrz8vLMvvDwcOXn53v0nzp1SgUFBR5jzjbHmfv4I7vdLofD4bEBAIDLV60NRFFRUQoPD1dGRobZ5na7tWnTJrlcLkmSy+VSYWGhsrKyzDGrV69WeXm5unTpYo5Zt26dSktLzTHp6elq1aqVGjZsWENHAwAAajOfBqLi4mJt2bJFW7ZskXR6IfWWLVu0b98+2Ww2jR49Ws8995w+++wzbdu2TYMGDVJERIR5JVqbNm1066236pFHHtHmzZu1YcMGjRgxQgMGDFBERIQk6f7771dgYKCGDBmiHTt26L333tOcOXM0duxYHx01AACober4cuffffedevXqZb6uCCmJiYlKTU3V+PHjdfToUT366KMqLCxU9+7dtXLlSgUFBZnvWbRokUaMGKHevXvLz89PCQkJmjt3rtnvdDr1xRdfKCkpSZ06dVLjxo2VnJzsca8iAABgbbXmPkS1GfchAnCxuA8RcG7chwgAAMDHCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDy6vi6AEgtJ6b5ugSg1to7Pd7XJQCwAM4QAQAAy7NUIHr11VfVsmVLBQUFqUuXLtq8ebOvSwIAALWAZQLRe++9p7Fjx+qZZ57Rv//9b7Vv315xcXHKz8/3dWkAAMDHLBOIXnrpJT3yyCMaPHiwYmJilJKSonr16umtt97ydWkAAMDHLLGo+uTJk8rKytKkSZPMNj8/P8XGxiozM7PS+JKSEpWUlJivi4qKJElut7ta6isvOVYt8wKXg+r6uatp/JwD51YdP+sVcxqG8adjLRGI/u///k9lZWUKCwvzaA8LC9OuXbsqjZ82bZqmTJlSqT0yMrLaagRwds7Zvq4AQE2ozp/1I0eOyOl0nnOMJQKRtyZNmqSxY8ear8vLy1VQUKBGjRrJZrP5sDJUN7fbrcjISO3fv18Oh8PX5QCoJvysW4NhGDpy5IgiIiL+dKwlAlHjxo3l7++vvLw8j/a8vDyFh4dXGm+322W32z3aQkJCqrNE1DIOh4NfkoAF8LN++fuzM0MVLLGoOjAwUJ06dVJGRobZVl5eroyMDLlcLh9WBgAAagNLnCGSpLFjxyoxMVGdO3fW9ddfr9mzZ+vo0aMaPHiwr0sDAAA+ZplA1L9/f/32229KTk5Wbm6urr32Wq1cubLSQmtYm91u1zPPPFPpI1MAlxd+1vFHNuN8rkUDAAC4jFliDREAAMC5EIgAAIDlEYgAAIDlEYgAAIDlEYhQaz300EOy2Wyy2WwKCAhQVFSUxo8frxMnTphjKvptNpuCg4N11VVX6aGHHlJWVpbHXGvWrPEYW7E9/fTT5pgffvhBPXr0UFBQkCIjIzVjxgyPOW666aazzhEfH2+OMQxDycnJatasmerWravY2Fjt3r27mr5DgDWVlZXphhtuUL9+/Tzai4qKFBkZqaeeekqSzvrzumTJkkrzHT9+XKGhoWrcuLHHcyxhLQQi1Gq33nqrDh06pD179mjWrFl67bXX9Mwzz3iMefvtt3Xo0CHt2LFDr776qoqLi9WlSxctXLiw0nzZ2dk6dOiQuU2cOFHS6dv49+nTRy1atFBWVpZefPFFTZ48Wa+//rr53o8++sjjvdu3b5e/v7/+/ve/m2NmzJihuXPnKiUlRZs2bVJwcLDi4uI8QhyAi+Pv76/U1FStXLlSixYtMttHjhyp0NBQj98RFb8fKra77rqr0nwffvih/vrXv6p169b65JNPauAIUCsZQC2VmJho3HnnnR5t/fr1Mzp06GC+lmR8/PHHld47aNAgo0GDBkZBQYFhGIbx1VdfGZKMw4cPn3Vf8+bNMxo2bGiUlJSYbRMmTDBatWr1H+ubNWuW0aBBA6O4uNgwDMMoLy83wsPDjRdffNEcU1hYaNjtduPdd981DMMwXC6XMX78eI958vPzjTp16hhr1679j/sCUNmcOXOMhg0bGgcPHjQ++eQTIyAgwNiyZYvZ/59+P/zRTTfdZKSkpBjz5883brnlFrP9tddeM5o1a2aUlZV5jL/jjjuMwYMHV9lxoHbgDBEuGdu3b9fGjRsVGBj4p2PHjBmjI0eOKD09/bzmzszMVM+ePT3mjouLU3Z2tg4fPnzW97z55psaMGCAgoODJUk5OTnKzc1VbGysOcbpdKpLly7KzMyUJA0cOFBLliyRccbtv9577z1FRESoR48e51UrgNNGjhyp9u3b68EHH9Sjjz6q5ORktW/f3mNMUlKSGjdurOuvv15vvfWWx8+eJP3888/KzMzUvffeq3vvvVfr16/XL7/8Ikn6+9//rt9//11fffWVOb6goEArV67UwIEDq/8AUaMIRKjVli1bpvr16ysoKEht27ZVfn6+xo0b96fva926tSRp7969Hu3NmzdX/fr1ze3333+XJOXm5la6a3nF69zc3Erzb968Wdu3b9fQoUPNtopxZ5unou/ee+/VwYMH9fXXX5v9ixcv1n333SebzfanxwXg/2ez2TR//nxlZGQoLCzM/Ai8wtSpU7V06VKlp6crISFBjz32mF5++WWPMW+99ZZuu+02NWzYUKGhoYqLi9Pbb78tSWrYsKFuu+02LV682Bz/wQcfqHHjxurVq1f1HyBqFIEItVqvXr20ZcsWbdq0SYmJiRo8eLASEhL+9H0V/wv8Y8hYv369tmzZYm4NGza8oLrefPNNtW3bVtdff71X72vSpIn69OljrnvIyclRZmYm/9sELtBbb72levXqKScnRwcOHPDo+8c//qFu3bqpQ4cOmjBhgsaPH68XX3zR7C8rK9M777yjBx54wGx74IEHlJqaqvLyckmnz+p++OGH5mLrRYsWacCAAfLz48/n5YZ/UdRqwcHBio6OVvv27fXWW29p06ZNevPNN//0fTt37pQkRUVFebRHRUUpOjra3Cp+qYWHhysvL89jbMXr8PBwj/ajR49qyZIlGjJkiEd7xbizzXPmHAMHDtQHH3yg0tJSLV68WG3btlXbtm3/9JgAeNq4caNmzZqlZcuW6frrr9eQIUMqfSR2pi5duujAgQNmuFm1apV+/fVX9e/fX3Xq1FGdOnU0YMAA/fLLL8rIyJAk3X777TIMQ2lpadq/f7/Wr1/Pf2AuUwQiXDL8/Pz0//7f/9PTTz+t48ePn3Ps7Nmz5XA4PNbznIvL5dK6detUWlpqtqWnp6tVq1aVziK9//77Kikp8fhfpXQ6bIWHh5u/SKXTV69t2rRJLpfLbLvzzjt14sQJrVy5UosXL+aXK3ABjh07poceekjDhw9Xr1699Oabb2rz5s1KSUn5j++pOCtc8UDXinWAZ5413rJliwYMGGD+xysoKEj9+vXTokWL9O6776pVq1bq2LFjjRwjaphPl3QD53C2q8xKS0uNv/zlL+aVXJKMt99+2zh06JCxd+9e44svvjASEhIMf39/Y9GiReb7/uwqs8LCQiMsLMx48MEHje3btxtLliwx6tWrZ7z22muVxnbv3t3o37//WeeZPn26ERISYnz66afGDz/8YNx5551GVFSUcfz4cY9xAwcONNq3b2/YbDbjl19+8eK7AsAwDGPUqFFGdHS0cfToUbMtJSXFqF+/vpGTk2N89tlnxhtvvGFs27bN2L17tzFv3jyjXr16RnJysmEYp6/uDAgIMFasWFFp7uXLlxt2u934/fffDcMwjPT0dMNutxutWrUynn322Zo5QNQ4AhFqrbMFIsMwjGnTphlNmjQxiouLDUnmFhQUZPzXf/2XkZiYaGRlZXm8588CkWEYxtatW43u3bsbdrvd+Mtf/mJMnz690phdu3YZkowvvvjirHOUl5cb//jHP4ywsDDDbrcbvXv3NrKzsyuNW758uSHJ6Nmz57m/CQAqWbNmjeHv72+sX7++Ul+fPn2Mm2++2Vi+fLlx7bXXGvXr1zeCg4ON9u3bGykpKeYl9P/85z+NkJAQ4+TJk5XmKCkpMUJCQow5c+YYhmEYZWVlRrNmzQxJxs8//1y9BwefsRnGOT5wBQAAsADWEAEAAMsjEAEAAMsjEAEAAMsjEAEAAMsjEAEAAMsjEAEAAMsjEAEAAMsjEAEAAMsjEAEAAMsjEAGodR566CHZbLZK208//XTRc6empiokJOTiiwRwWanj6wIA4GxuvfVWvf322x5tTZo08VE1Z1daWqqAgABflwGgCnCGCECtZLfbFR4e7rH5+/vr008/VceOHRUUFKQrr7xSU6ZM0alTp8z3vfTSS2rbtq2Cg4MVGRmpxx57TMXFxZKkNWvWaPDgwSoqKjLPOk2ePFmSZLPZ9Mknn3jUEBISotTUVEnS3r17ZbPZ9N577+nGG29UUFCQFi1aJElasGCB2rRpo6CgILVu3Vrz5s0z5zh58qRGjBihZs2aKSgoSC1atNC0adOq7xsH4IJwhgjAJWP9+vUaNGiQ5s6dqx49eujnn3/Wo48+Kkl65plnJEl+fn6aO3euoqKitGfPHj322GMaP3685s2bpxtuuEGzZ89WcnKysrOzJUn169f3qoaJEydq5syZ6tChgxmKkpOT9corr6hDhw76/vvv9cgjjyg4OFiJiYmaO3euPvvsMy1dulRXXHGF9u/fr/3791ftNwbARSMQAaiVli1b5hFWbrvtNh0+fFgTJ05UYmKiJOnKK6/Us88+q/Hjx5uBaPTo0eZ7WrZsqeeee07Dhg3TvHnzFBgYKKfTKZvNpvDw8Auqa/To0erXr5/5+plnntHMmTPNtqioKP3444967bXXlJiYqH379umqq65S9+7dZbPZ1KJFiwvaL4DqRSACUCv16tVL8+fPN18HBwerXbt22rBhg55//nmzvaysTCdOnNCxY8dUr149ffnll5o2bZp27dolt9utU6dOefRfrM6dO5tfHz16VD///LOGDBmiRx55xGw/deqUnE6npNMLxG+55Ra1atVKt956q/r27as+ffpcdB0AqhaBCECtFBwcrOjoaI+24uJiTZkyxeMMTYWgoCDt3btXffv21fDhw/X8888rNDRUX3/9tYYMGaKTJ0+eMxDZbDYZhuHRVlpaeta6zqxHkt544w116dLFY5y/v78kqWPHjsrJydGKFSv05Zdf6t5771VsbKw++OCDP/kOAKhJBCIAl4yOHTsqOzu7UlCqkJWVpfLycs2cOVN+fqevGVm6dKnHmMDAQJWVlVV6b5MmTXTo0CHz9e7du3Xs2LFz1hMWFqaIiAjt2bNHAwcO/I/jHA6H+vfvr/79++uee+7RrbfeqoKCAoWGhp5zfgA1h0AE4JKRnJysvn376oorrtA999wjPz8/bd26Vdu3b9dzzz2n6OholZaW6uWXX9btt9+uDRs2KCUlxWOOli1bqri4WBkZGWrfvr3q1aunevXq6eabb9Yrr7wil8ulsrIyTZgw4bwuqZ8yZYpGjRolp9OpW2+9VSUlJfruu+90+PBhjR07Vi+99JKaNWumDh06yM/PT++//77Cw8O5FxJQy3DZPYBLRlxcnJYtW6YvvvhC1113nbp27apZs2aZC5Xbt2+vl156Sf/93/+ta665RosWLap0ifsNN9ygYcOGqX///mrSpIlmzJghSZo5c6YiIyPVo0cP3X///XryySfPa83R0KFDtWDBAr399ttq27atbrzxRqWmpioqKkqS1KBBA82YMUOdO3fWddddp71792r58uXmGSwAtYPN+OOH5gAAABbDf1EAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDl/X+mfdKlTcdinAAAAABJRU5ErkJggg==",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "model1.feature_importance_plot()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "id": "7f1dd508",
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "ValueError",
+ "evalue": "zero-dimensional arrays cannot be concatenated",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[23], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m cv\u001b[39m.\u001b[39;49mcross_validation(dfx, dfy, [\u001b[39m'\u001b[39;49m\u001b[39mRDF070v\u001b[39;49m\u001b[39m'\u001b[39;49m, \u001b[39m'\u001b[39;49m\u001b[39mX5Av\u001b[39;49m\u001b[39m'\u001b[39;49m])\n",
+ "File \u001b[0;32m~/projects/pyQSARplus/cross_validation.py:63\u001b[0m, in \u001b[0;36mcross_validation.__init__\u001b[0;34m(self, X_data, y_data, feature_set)\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39moriginal_q2 \u001b[39m=\u001b[39m q2_score(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39my, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmlr\u001b[39m.\u001b[39mpredict(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mx))\n\u001b[1;32m 62\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mxx \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mconcatenate((\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mx))\n\u001b[0;32m---> 63\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39myy \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mconcatenate((\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49my))\n",
+ "File \u001b[0;32m<__array_function__ internals>:180\u001b[0m, in \u001b[0;36mconcatenate\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
+ "\u001b[0;31mValueError\u001b[0m: zero-dimensional arrays cannot be concatenated"
+ ]
+ }
+ ],
+ "source": [
+ "cv.cross_validation(dfx, dfy, ['RDF070v', 'X5Av'])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ad197714",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.12.0"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/__init__.py b/src/__init__.py
new file mode 100644
index 0000000..d8a1090
--- /dev/null
+++ b/src/__init__.py
@@ -0,0 +1 @@
+name = "qsarify"
diff --git a/classification.py b/src/classification.py
similarity index 68%
rename from classification.py
rename to src/classification.py
index 5ea9c72..4ee1594 100644
--- a/classification.py
+++ b/src/classification.py
@@ -1,40 +1,44 @@
#-*- coding: utf-8 -*-
-# Author: Stephen Szwiec
+# Author: Stephen Szwiec
# Date: 2023-02-19
# Description: Classification Scoring Module
-"""
-Copyright (C) 2023 Stephen Szwiec
-
-This file is part of pyqsarplus.
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program. If not, see .
+#
+#Copyright (C) 2023 Stephen Szwiec
+#
+#This file is part of qsarify.
+#
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program. If not, see .
"""
+Classification Scoring Module
+This module provides summary information about Classification
+"""
import numpy as np
from sklearn.metrics import accuracy_score
+
class ClassifierScore :
"""
Provides summary information about Classification
-
+
Parameters
----------
y_data : pandas DataFrame , shape = (n_samples,)
pred_y : pandas DataFrame , shape = (n_samples,)
=> predicted Y values as result of classification
-
+
Sub functions
-------
score (self)
@@ -45,10 +49,11 @@ def __init__ (self,y_data,pred_y) :
"""
Initializes the classifer
"""
+ # Initialize the variables
self.y_data = y_data
self.pred_y = pred_y
self.real_y = [] #hash y_data
-
+ # Hash the y_data
for i in np.array(self.y_data) :
self.real_y.append(i[0])
@@ -59,8 +64,10 @@ def score (self) :
-------
None
"""
+ # Initialize the variables
n = 0
cnt = 0
+ # Count the number of wrong predictions
for i in np.array(self.real_y) :
if i != self.pred_y[n] :
cnt += 1
@@ -73,23 +80,25 @@ def tf_table(self) :
"""
Calculate Precision & Recall
Generates a confusion matrix
-
+
Returns
-------
None
"""
+ # Initialize the variables
one = 0
zero = 0
n = 0
cnt = 0
realzero = 0
realone = 0
+ # Initialize the confusion matrix
for i in np.array(self.y_data) :
if i[0] == 0 :
zero += 1
if i[0] == 1 :
one += 1
-
+ # Count the number of wrong predictions
for i in np.array(self.y_data):
if i[0] != self.pred_y[n]:
#print ('real',i[0],'///','pred',y_pred[n])
@@ -99,8 +108,7 @@ def tf_table(self) :
realone += 1
cnt +=1
n += 1
-
-
+ # Print the results
print(('Number of 1 :',one))
print('Number of 0 :',zero)
print('True Positive(real 1 but pred 1) :',one-realone) #TP
@@ -109,4 +117,3 @@ def tf_table(self) :
print('False Negative(real 1 but pred 0) :',realone) #FN
print('Precision', (one-realone)/((one-realone)+realzero)) # TP / TP+FP
print('Recall',(one-realone)/((one-realone)+realone)) # TP / TP+FN
-
diff --git a/clustering.py b/src/clustering.py
similarity index 72%
rename from clustering.py
rename to src/clustering.py
index 694f412..4db562c 100644
--- a/clustering.py
+++ b/src/clustering.py
@@ -2,32 +2,45 @@
# Author: Stephen Szwiec
# Date: 2023-02-19
# Description: Clustering Module
-"""
-Copyright (C) 2023 Stephen Szwiec
-
-This file is part of pyqsarplus.
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
+#
+#Copyright (C) 2023 Stephen Szwiec
+#
+#This file is part of qsarify.
+#
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program. If not, see .
+#
+#
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+"""
+Clustering Module
-You should have received a copy of the GNU General Public License
-along with this program. If not, see .
+This module contains functions for clustering features based on hierarchical clustering method
+and calculating the cophenetic correlation coefficient of linkages. The cophenetic correlation
+coefficient is a measure of the correlation between the distance of observations in feature space
+and the distance of observations in cluster space. The cophenetic correlation coefficient is
+calculated for each linkage method and the method with the highest cophenetic correlation
+coefficient is used to cluster the features. The cophenetic correlation coefficient is calculated
+using the scipy.cluster.hierarchy.cophenet function.
"""
+
import numpy as np
import pandas as pd
from pandas import DataFrame, Series
import matplotlib.pyplot as plt
from scipy.spatial.distance import pdist, squareform
from scipy.cluster.hierarchy import linkage, dendrogram, fcluster, cophenet
-from sklearn.decomposition import PCA
def cophenetic(X_data):
"""
@@ -35,7 +48,8 @@ def cophenetic(X_data):
Parameters
----------
- X_data : pandas DataFrame, shape = (n_samples, n_features)
+ X_data : pandas DataFrame, shape = (n_samples, m_features)
+ method : str, method for linkage generation, default = 'corr' (Pearson correlation)
Returns
-------
@@ -63,7 +77,7 @@ class featureCluster:
Parameters
----------
X_data : pandas DataFrame, shape = (n_samples, n_features)
- link : str, kind of linkage method, default = 'average'
+ link : str, kind of linkage method, default = 'average', 'complete', 'single'
cut_d : int, depth in cluster(dendrogram), default = 3
Sub functions
@@ -71,8 +85,8 @@ class featureCluster:
set_cluster(self)
cluster_dist(self)
"""
-
- def __init__(self, X_data, link='average', cut_d=3):
+
+ def __init__(self, X_data, method='corr', link='average', cut_d=3):
"""
Initializes cluster object:
Makes a cluster of features based on hierarchical clustering method
@@ -85,14 +99,15 @@ def __init__(self, X_data, link='average', cut_d=3):
cut_d : int, depth in cluster(dendrogram), default = 3
This is a tunable parameter for clustering
"""
+ self.method = method
self.cluster_info = []
self.assignments = np.array([])
self.cluster_output = DataFrame()
self.cludict = {}
self.X_data = X_data
- self.xcorr = pd.DataFrame(abs(np.corrcoef(self.X_data, rowvar=False)), columns=X_data.columns, index=X_data.columns)
self.link = link
self.cut_d = cut_d
+ self.xcorr = pd.DataFrame(abs(np.corrcoef(self.X_data, rowvar=False)), columns=X_data.columns, index=X_data.columns)
def set_cluster(self, verbose=False, graph=False):
"""
@@ -120,7 +135,7 @@ def set_cluster(self, verbose=False, graph=False):
self.cluster_info.append( [k for k, v in self.cludict.items() if v == t] )
if verbose:
print('\n','\x1b[1;46m'+'Cluster'+'\x1b[0m',t,self.cluster_info[t-1],)
- if graph:
+ if graph:
plt.figure(figsize=(25, 40))
plt.title('Hierarchical Clustering Dendrogram')
plt.xlabel('sample index')
@@ -137,7 +152,7 @@ def cluster_dist(self):
-------
None
"""
-
+
# have we actually clustered? If not, please do so first:
if self.assignments.any() == False:
self.set_cluster()
@@ -148,7 +163,8 @@ def cluster_dist(self):
dist_box = [ (np.array([self.xcorr.loc[i,i]]).sum() - len(i)/2)/(len(i)**2 - len(i)/2) for i in cluster if len(i) > 1]
plt.hist(dist_box)
plt.ylabel("Frequency")
- plt.xlabel("Correlation coefficient of each cluster")
+ if self.method == 'info':
+ plt.xlabel("Shannon mutual information of each cluster")
+ else:
+ plt.xlabel("Correlation coefficient of each cluster")
plt.show()
-
-
\ No newline at end of file
diff --git a/src/cross_validation.py b/src/cross_validation.py
new file mode 100644
index 0000000..d9c95d5
--- /dev/null
+++ b/src/cross_validation.py
@@ -0,0 +1,185 @@
+#-*- coding: utf-8 -*-
+# Author: Stephen Szwiec
+# Date: 2023-02-19
+# Description: Cross Validation Module
+#
+#Copyright (C) 2023 Stephen Szwiec
+#
+#This file is part of qsarify.
+#
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program. If not, see .
+#
+
+"""
+Cross Validation Module
+
+This module contains the cross_validation class which is used to perform cross validation on a data set using a linear regression model
+
+"""
+from sklearn.model_selection import KFold, LeaveOneOut
+from matplotlib import pyplot as plt
+import numpy as np
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error , r2_score
+from sklearn.model_selection import LeaveOneOut
+from sklearn.metrics import mean_squared_error
+from sklearn.preprocessing import MinMaxScaler
+import numpy as np
+from qsar_scoring import q2_score, q2f_score, q2f3_score, ccc_score
+
+class cross_validation:
+
+ """
+ Class for performing cross validation on a data set using a linear regression model
+
+
+ initializes a cross_validation object, performs the regression and stores the results
+
+ Parameters
+ ----------
+ X_data : pandas dataframe, shape = [n_samples, n_features]
+ y_data : pandas dataframe, shape = [n_samples, ]
+ feature_set : list, set of features to be used for the model
+ verbose : boolean, if true, performs all scoring functions
+ """
+ def __init__ (self, X_data, y_data, feature_set):
+ """
+ Does the preliminary work of regenerating the original model locally for later use and comparison
+ """
+ self.mlr = LinearRegression()
+ self.feature_set = feature_set
+ self.x = X_data.loc[:, feature_set].values
+ self.y = y_data.values
+ self.mlr.fit(self.x, self.y)
+ self.original_coef = self.mlr.coef_
+ self.original_intercept = self.mlr.intercept_
+ self.original_r2 = self.mlr.score(self.x, self.y)
+ self.original_q2 = q2_score(self.y, self.mlr.predict(self.x))
+
+
+
+ def kfoldcv(self, k=5, verbose=False, show_plots=False):
+ """
+ Performs k-fold cross validation
+
+ Parameters
+ ----------
+ k : int, number of folds
+ verbose : boolean, if true, performs all scoring functions
+ show_plots : boolean, if true, shows plots of validation results
+
+ Returns
+ -------
+ None
+ """
+ # create a k-fold object iterator for data
+ kf = KFold(n_splits=k, shuffle=True)
+ kf.get_n_splits(self.x)
+ # initialize lists to store results
+ best_model = []
+ predY = np.zeros_like(self.y)
+ r2kf = []
+ q2kf = []
+ interceptkf = []
+ coefkf = []
+ trainset = []
+ testset = []
+ if verbose:
+ q2f1kf = []
+ q2f2kf = []
+ q2f3kf = []
+ ccckf = []
+ # iterate over folds
+ for train, test in kf.split(self.x):
+ scaler = MinMaxScaler()
+ scaler.fit(self.x[train])
+ x_train = scaler.transform(self.x[train])
+ x_test = scaler.transform(self.x[test])
+ # fit model to training data
+ clf = LinearRegression()
+ clf.fit(x_train, self.y[train])
+ predY[train] = clf.predict(x_train)
+ predY[test] = clf.predict(x_test)
+ rs = clf.score(x_train, self.y[train])
+ qs = clf.score(x_test, self.y[test])
+ intercept = clf.intercept_
+ coef = clf.coef_
+ trainset_index = train
+ testset_index = test
+ if verbose:
+ q2f1 = q2f_score(self.y[test], predY[test], np.mean(self.y[train]))
+ q2f2 = q2f_score(self.y[test], predY[test], np.mean(self.y[test]))
+ q2f3 = q2f3_score(self.y[test], predY[test], len(train), len(test))
+ ccc = ccc_score(self.y, predY)
+ # store results
+ r2kf.append(rs)
+ q2kf.append(qs)
+ interceptkf.append(intercept)
+ coefkf.append(coef)
+ trainset.append(trainset_index)
+ testset.append(testset_index)
+ if verbose:
+ q2f1kf.append(q2f1)
+ q2f2kf.append(q2f2)
+ q2f3kf.append(q2f3)
+ ccckf.append(ccc)
+ # calculate average results
+ rmse = np.sqrt(mean_squared_error(predY, self.y))
+ maxq2 = np.max(np.array(q2kf))
+ index = q2kf.index(maxq2)
+ # store results
+ mid = []
+ mid.append(np.mean(np.array(q2kf)))
+ mid.append(np.mean(np.array(r2kf)))
+ mid.append(rmse)
+ mid.append(coefkf[index])
+ mid.append(interceptkf[index])
+ mid.append(trainset_index[index])
+ mid.append(testset_index[index])
+ if verbose:
+ mid.append(np.mean(np.array(q2f1kf)))
+ mid.append(np.mean(np.array(q2f2kf)))
+ mid.append(np.mean(np.array(q2f3kf)))
+ mid.append(np.mean(np.array(ccckf)))
+ best_model.append(mid)
+
+ best_model.sort()
+ best = best_model[-1]
+
+
+ print('R^2CV mean: {:.6}'.format(best[1]))
+ print('Q^2CV mean: {:.6}'.format(best[0]))
+ print('RMSE CV : {:.6}'.format(best[2]))
+ print('Features set =', self.feature_set)
+ print('Model coeff = ',best[3])
+ print('Model intercept = ',best[4])
+ if verbose:
+ print('Q^2F1CV mean: {:.6}'.format(best[7]))
+ print('Q^2F2CV mean: {:.6}'.format(best[8]))
+ print('Q^2F3CV mean: {:.6}'.format(best[9]))
+ print('CCC CV : {:.6}'.format(best[10]))
+
+
+ if show_plots:
+ pred_plotY = np.zeros_like(self.y)
+ g_mlr = LinearRegression()
+ g_mlr.fit(self.x[trainset_index], self.y[trainset_index])
+ pred_plotY[trainset_index] = g_mlr.predict(self.x[trainset_index])
+ pred_plotY[testset_index] = g_mlr.predict(self.x[testset_index])
+ plt.ylabel('Predicted Y')
+ plt.xlabel('Actual Y')
+ plt.scatter(self.y[trainset_index], pred_plotY[trainset_index], label='Training set', color='grey')
+ plt.scatter(self.y[testset_index], pred_plotY[testset_index], label='Test set', color='red')
+ plt.plot([self.y.min() , self.y.max()] , [[self.y.min()],[self.y.max()]],"black" )
+ plt.show()
diff --git a/data_tools.py b/src/data_tools.py
similarity index 77%
rename from data_tools.py
rename to src/data_tools.py
index b047bf1..c430486 100644
--- a/data_tools.py
+++ b/src/data_tools.py
@@ -2,25 +2,44 @@
# Author: Stephen Szwiec
# Date: 2023-02-19
# Description: Data Preprocessing Module
+#
+#Copyright (C) 2023 Stephen Szwiec
+#
+#This file is part of qsarify.
+#
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program. If not, see .
+#
+#
+
"""
-Copyright (C) 2023 Stephen Szwiec
+Data Preprocessing Module
-This file is part of pyqsarplus.
+This module contains functions for data preprocessing, including:
+ - removing features with 'NaN' as value
+ - removing features with constant values
+ - removing features with low variance
+ - removing features with 'NaN' as value when calculating correlation coefficients
+ - generating a sequential train-test split by sorting the data by response variable
+ - generating a random train-test split
+ - scaling data
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
+The main function of this module is `clean_data`, which performs all of the above functions.
+
+"""
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program. If not, see .
-"""
import numpy as np
from numpy import ndarray
import pandas as pd
@@ -45,8 +64,6 @@ def rm_nan(X_data):
# delete the features with 'NaN' as value
return X_data.drop(X_data.columns[A], axis=1)
-
-
def rm_constant(X_data):
"""
Remove features with constant values
@@ -169,7 +186,7 @@ def scale_data(X_train, X_test):
X_test_scaled = pd.DataFrame(scaler.transform(X_test), columns=list(X_test.columns.values))
return X_train_scaled, X_test_scaled
-def clean_data(X_data, y_data, split=sorted, cutoff=None, plot=False):
+def clean_data(X_data, y_data, split='sorted', test_size=0.2, cutoff=None, plot=False):
"""
Perform the entire data cleaning process as one function
Optionally, plot the correlation matrix
@@ -178,11 +195,17 @@ def clean_data(X_data, y_data, split=sorted, cutoff=None, plot=False):
----------
X_data : pandas DataFrame, shape = (n_samples, n_features)
split : string, optional, 'sorted' or 'random'
+ test_size : float, optional, default = 0.2
cutoff : float, optional, auto-correlaton coefficient below which we keep
plot : boolean, optional, default = False
Returns
-------
+ X_train : pandas DataFrame , shape = (n_samples, m_features)
+ X_test : pandas DataFrame , shape = (p_samples, m_features)
+ y_train : pandas DataFrame , shape = (n_samples, 1)
+ y_test : pandas DataFrame , shape = (p_samples, 1)
+
"""
# Create a deep copy of the data
@@ -198,9 +221,9 @@ def clean_data(X_data, y_data, split=sorted, cutoff=None, plot=False):
df = rm_lowVar(df, cutoff)
# Create split
if split == 'random':
- X_train, X_test, y_train, y_test = random_split(df, y_data)
+ X_train, X_test, y_train, y_test = random_split(df, y_data, test_size)
else:
- X_train, X_test, y_train, y_test = random_split(df, y_data)
+ X_train, X_test, y_train, y_test = sorted_split(df, y_data, test_size)
# Scale the data and return
X_train, X_test = scale_data(X_train, X_test)
if plot:
diff --git a/export_model.py b/src/export_model.py
similarity index 71%
rename from export_model.py
rename to src/export_model.py
index d8ca276..af76ba1 100644
--- a/export_model.py
+++ b/src/export_model.py
@@ -2,25 +2,34 @@
# Author: Stephen Szwiec
# Date: 2023-02-19
# Description: Model Export Module
-"""
-Copyright (C) 2023 Stephen Szwiec
-
-This file is part of pyqsarplus.
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
+#
+# Copyright (C) 2023 Stephen Szwiec
+#
+#This file is part of qsarify.
+#
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program. If not, see .
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+"""
+Model Export Module
-You should have received a copy of the GNU General Public License
-along with this program. If not, see .
+This module contains the ModelExport class which is used to
+summarize and export the results of a model. It contains
+functions to plot the training data, print scoring metrics,
+and show useful plots such as the Williams Plot.
"""
+
import numpy as np
import pandas as pd
from pandas import DataFrame
@@ -100,7 +109,7 @@ def train_plot(self, interval=False):
def scores(self, verbose=False):
"""
- Return scoring metrics for the model
+ Print scoring metrics for the model
Parameters
----------
@@ -108,7 +117,7 @@ def scores(self, verbose=False):
Returns
-------
- dict of scoring metrics
+ None
"""
scores = {}
scores["RMSE"] = np.sqrt(mean_squared_error(self.y, self.y_pred))
@@ -117,12 +126,11 @@ def scores(self, verbose=False):
scores["Q2"] = q2_score(self.ey, self.ey_pred)
if verbose:
scores["Q2F1"] = q2f_score(self.ey, self.ey_pred, np.mean(self.y))
- scores["Q2F2"] = q2f_score(self.ey, self.ey_pred, np.median(self.ey))
+ scores["Q2F2"] = q2f_score(self.ey, self.ey_pred, np.mean(self.ey))
scores["Q2F3"] = q2f3_score(self.ey, self.ey_pred, len(self.y), len(self.ey))
scores["CCC"] = ccc_score(np.append(self.y, self.ey), np.append(self.y_pred, self.ey_pred))
for key, value in scores.items():
print(key, ":", value)
- return scores
def williams_plot(self):
@@ -159,10 +167,10 @@ def williams_plot(self):
plt.ylabel("Std. Residuals")
plt.xlabel(F"Hat Values (h*={hii:.2f})")
plt.ylim([-3.5,3.5])
- plt.scatter(leverage_in,res,color=['lightblue'])
- plt.scatter(leverage_ex,residuals_ex,color=['orange'])
+ plt.scatter(leverage_in,res,color=['lightblue'], label="Training Data")
+ plt.scatter(leverage_ex,residuals_ex,color=['orange'], label="Test Data")
plt.plot()
- plt.legend(["Applicability Domain", "Training Data", "Test Data"], loc="upper right")
+ plt.legend(loc="upper right")
plt.show()
def mlr(self):
@@ -245,7 +253,7 @@ def external_set(self, verbose=False, interval=False):
plt.errorbar(self.y, self.y_pred, yerr=self.y_pred_std, fmt='o', color='lightblue', ecolor='lightgray', elinewidth=3, capsize=0)
plt.errorbar(self.ey, self.ey_pred, yerr=self.ey_pred_std, fmt='o', color='orange', ecolor='lightgray', elinewidth=3, capsize=0)
plt.plot([self.y.min() , self.y.max()] , [[self.y.min()],[self.y.max()]],"black" )
- plt.legend(["Ideal", "Training Data", "Test Data"], loc="upper left")
+ plt.legend(["Training Data", "Test Data", "Predicted"], loc="upper left")
plt.show()
@@ -390,102 +398,3 @@ def feature_importance_table(self):
"""
feature_importance = self.feature_importance()
return DataFrame(feature_importance, index=self.feature_set, columns=['feature importance'])
-
- def __radar_factory__(num_vars, frame='polygon'):
- """
- Create a radar chart with `num_vars` axes.
-
- Credit: https://matplotlib.org/stable/gallery/specialty_plots/radar_chart.html
-
- Parameters
- ----------
- num_vars : int, number of variables for radar chart
- frame : str, shape of frame for radar chart, defaults to 'circle'
-
- """
-
- theta = np.linspace(0, 2*np.pi, num_vars, endpoint=False)
- # close the plot
- class RadarTransform(PolarAxes.PolarTransform):
-
- def transform_path_non_affine(self, path):
- if path._interpolation_steps > 1:
- path = path.interpolated(num_vars)
- return Path(self.transform(path.vertices), path.codes)
-
- class RadarAxes(PolarAxes):
- name = 'radar'
- PolarTransform = RadarTransform
-
- def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
- # rotate plot such that the first axis is at the top
- self.set_theta_zero_location('N')
-
- def fill(self, *args, closed=True, **kwargs):
- """Override fill so that line is closed by default"""
- return super().fill(closed=closed, *args, **kwargs)
-
- def plot(self, *args, **kwargs):
- """Override plot so that line is closed by default"""
- lines = super().plot(*args, **kwargs)
- for line in lines:
- self._close_line(line)
-
- def _close_line(self, line):
- x, y = line.get_data()
- if x[0] != x[-1]:
- x = np.concatenate((x, [x[0]]))
- y = np.concatenate((y, [y[0]]))
- line.set_data(x, y)
-
- def set_varlabels(self, labels):
- self.set_thetagrids(np.degrees(theta), labels)
-
- def _gen_axes_patch(self):
- # The Axes patch must be centered at (0.5, 0.5) and of radius
- # 0.5 in axes coordinates.
- if frame == 'circle':
- return Circle((0.5, 0.5), 0.5)
- elif frame == 'polygon':
- return RegularPolygon((0.5, 0.5), num_vars,
- radius=.5, edgecolor="k")
- else:
- raise ValueError("unknown value for 'frame': %s" % frame)
-
- def _gen_axes_spines(self):
- if frame == 'circle':
- return super()._gen_axes_spines()
- elif frame == 'polygon':
- # spine_type must be 'left'/'right'/'top'/'bottom'/'circle'.
- spine = Spine(axes=self,
- spine_type='circle',
- path=Circle((0.5, 0.5), 0.5))
- spine.set_transform(self.transAxes)
- return {'polar': spine}
- else:
- raise ValueError("unknown value for 'frame': %s" % frame)
-
- register_projection(RadarAxes)
- return theta
-
- def radar_plot(self):
- """
- Creates a radar plot of the scoring metrics: r2, q2, rmse, rmse_ext, q2f1, q2f2, q2f3, and ccc
-7
- Returns
- -------
- None
- """
- n = 8
- theta = self.__radar_factory__(n)
- scores = self.scores(verbose=True).values.tolist()
- spoke_labels = ['r2', 'q2', 'rmse', 'rmse_ext', 'q2f1', 'q2f2', 'q2f3', 'ccc']
- fig, ax = plt.subplots(figsize=(9, 9), subplot_kw=dict(projection='radar'))
- fig.subplots_adjust(top=0.85, bottom=0.05)
- ax.set_rgrids([0.2, 0.4, 0.6, 0.8, 1.0])
- ax.set_title('Scoring Metrics', weight='bold', size='medium', position=(0.5, 1.1), horizontalalignment='center', verticalalignment='center')
- ax.plot(theta, scores)
- ax.fill(theta, scores, alpha=0.25)
- ax.set_varlabels(spoke_labels)
- plt.show()
diff --git a/feature_selection_multi.py b/src/feature_selection_multi.py
similarity index 86%
rename from feature_selection_multi.py
rename to src/feature_selection_multi.py
index 8c1783b..ab06de1 100644
--- a/feature_selection_multi.py
+++ b/src/feature_selection_multi.py
@@ -2,25 +2,34 @@
# Author: Stephen Szwiec
# Date: 2023-02-19
# Description: Multi-Processing Feature Selection Module
-"""
-Copyright (C) 2023 Stephen Szwiec
-
-This file is part of pyqsarplus.
+#
+#Copyright (C) 2023 Stephen Szwiec
+#
+#This file is part of qsarify.
+#
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program. If not, see .
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+"""
+Multi-Processing Feature Selection Module
-You should have received a copy of the GNU General Public License
-along with this program. If not, see .
+This module contains the functions for performing feature selection using
+the clustering module's output as a guide for feature selection, and implements
+a genetic algorithm for feature selection using reflection.
"""
+
import datetime
import random
import numpy as np
@@ -91,9 +100,9 @@ def selection(X_data, y_data, cluster_info, model="regression", learning=500000,
learning : default=500000, number of overall models to be trained
bank : default=200, number of models to be trained in each iteration
component : default=4, number of features to be selected
- interval : optional, default=1000, print current scoring and selected features
+ interval : optional, default=1000, print current scoring and selected features
every interval
- cores: optional, default=(mp.cpu_count()*2)-1, number of processes to be used
+ cores: optional, default=(mp.cpu_count()*2)-1, number of processes to be used
for multiprocessing; default is twice the number of cores minus 1, which
is assuming you have SMT, HT, or something similar) If you have a large
number of cores, you may want to set this to a lower number to avoid
@@ -160,4 +169,4 @@ def selection(X_data, y_data, cluster_info, model="regression", learning=500000,
fi = datetime.datetime.now()
fiTime = fi.strftime('%H:%M:%S')
print("Finish Time : ", fiTime)
- return scoring_bank[0][1]
\ No newline at end of file
+ return scoring_bank[0][1]
diff --git a/src/feature_selection_single.py b/src/feature_selection_single.py
new file mode 100644
index 0000000..5299c58
--- /dev/null
+++ b/src/feature_selection_single.py
@@ -0,0 +1,228 @@
+#-*- coding: utf-8 -*-
+# Author: Stephen Szwiec
+# Date: 2023-02-19
+# Description: Single-Threaded Feature Selection Module
+#
+#Copyright (C) 2023 Stephen Szwiec
+#
+#This file is part of qsarify.
+#
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program. If not, see .
+
+"""
+Single-Threaded Feature Selection Module
+
+This module contains the single-threaded version of the feature selection algorithm,
+which is a genetic algorithm that uses a linear regression model to score each set of features,
+using the output of clustering to ensure that the features are not redundant.
+
+"""
+import datetime
+import random
+import numpy as np
+import pandas as pd
+import sklearn.linear_model as lm
+import itertools
+
+def mlr_selection(X_data, y_data, cluster_info, component, model="regression", learning=50000, bank=200, interval=1000):
+ """
+ Performs feature selection using a using a linear regression model and a genetic algorithm on a single thread.
+ This is the vanilla version of the algorithm, which is not parallelized.
+
+ Parameters
+ ----------
+ X_data: DataFrame, descriptor data
+ y_data: DataFrame, target data
+ cluster_info: dict, descriptor cluster information
+ component: int, number of features to select
+ model: str, learning algorithm to use, default = "regression"
+ learning: int, number of iterations to perform, default = 50000
+ bank: int, number of models to keep in the bank, default = 200
+ interval: int, number of iterations to perform before printing the current time, default = 1000
+
+ Returns
+ -------
+ best_model: list, best model found
+ best_score: float, best score found
+ """
+
+ now = datetime.datetime.now()
+ print("Start time: ", now.strftime('%H:%M:%S'))
+
+ if model == "regression":
+ print('\x1b[1;42m','Regression','\x1b[0m')
+ y_mlr = lm.LinearRegression()
+ e_mlr = lm.LinearRegression()
+ else:
+ print('\x1b[1;42m','Classification','\x1b[0m')
+ y_mlr = SVC(kernel='rbf', C=1, gamma=0.1, random_state=0)
+ e_mlr = SVC(kernel='rbf', C=1, gamma=0.1, random_state=0)
+
+ # a list of numbered clusters
+ nc = list(cluster_info.values())
+ num_clusters = list(range(max(nc)))
+
+ # extract information from dictionary by inversion
+ inv_cluster_info = dict()
+ for k, v in cluster_info.items():
+ inv_cluster_info.setdefault(v, list()).append(k)
+
+ # an ordered list of features in each cluster
+ cluster = list(dict(sorted(inv_cluster_info.items())).values())
+
+ # fill the interation bank with random models
+ # models contain 1-component number of features
+ # ensure the models are not duplicated and non redundant
+ index_sort_bank = set()
+ model_bank = [ ini_desc for _ in range(bank) for ini_desc in [sorted([random.choice(cluster[random.choice(num_clusters)]) for _ in range(random.randint(1,component))])] if ini_desc not in tuple(index_sort_bank) and not index_sort_bank.add(tuple(ini_desc))]
+
+ # score each set of features, saving each score and the corresponding feature set
+ scoring_bank = list(map(lambda x: [y_mlr.fit(np.array(X_data.loc[:,x]), y_data.values.ravel()).score(np.array(X_data.loc[:,x]), y_data), list(X_data.loc[:,x].columns.values)], model_bank))
+
+ def evolve(i):
+ """
+ Evolution of descriptors for learning algorithm, implemented as a function map
+
+ Parameters
+ ----------
+ i: list, descriptor set
+ """
+ i = i[1]
+ group_n = [cluster_info[x]-1 for x in i]
+ sw_index = random.randrange(0, len(i))
+ sw_group = random.randrange(0, max(nc))
+ while sw_group in group_n:
+ sw_group = random.randrange(0, max(nc))
+ b_set = [random.choice(cluster[sw_group]) if x == sw_index else i[x] for x in range(0, len(i))]
+ b_set.sort()
+ x = X_data[b_set].values
+ y = y_data.values.ravel()
+ score = e_mlr.fit(x, y).score(x, y)
+ return [score, b_set]
+
+ # perform main learning loop
+ for n in range(learning):
+ # initialize best score to the worst possible score
+ best_score = -float("inf")
+ # Evolve the bank of models and allow those surpassing the best score to replace the worst models up to the bank size
+ rank_filter = filter(lambda x, best_score=best_score: x[0] > best_score and (best_score := x[0]), map(evolve, scoring_bank))
+ scoring_bank = sorted(itertools.chain(scoring_bank, rank_filter), reverse = True)[:bank]
+ if n % interval == 0 and n != 0:
+ tt = datetime.datetime.now()
+ print(n, '=>', tt.strftime('%H:%M:%S'), scoring_bank[0])
+
+ # print output and return best model found during training
+ print("Best score: ", scoring_bank[0][0])
+ clulog = [cluster_info[y] for y in scoring_bank[0][1]]
+ print("Model's cluster info", clulog)
+ fi = datetime.datetime.now()
+ fiTime = fi.strftime('%H:%M:%S')
+ print("Finish Time : ", fiTime)
+ return scoring_bank[0][1]
+
+def rf_selection(X_data, y_data, cluster_info, component, model="regression", learning=50000, bank=200, interval=1000):
+ """
+ Performs feature selection using a using a random forest model and a genetic algorithm on a single thread.
+ This is the vanilla version of the algorithm, which is not parallelized.
+
+ Parameters
+ ----------
+ X_data: DataFrame, descriptor data
+ y_data: DataFrame, target data
+ cluster_info: dict, descriptor cluster information
+ component: int, number of features to select
+ model: str, learning algorithm to use, default = "regression"
+ learning: int, number of iterations to perform, default = 50000
+ bank: int, number of models to keep in the bank, default = 200
+ interval: int, number of iterations to perform before printing the current time, default = 1000
+
+ Returns
+ -------
+ best_model: list, best model found
+ best_score: float, best score found
+ """
+
+ now = datetime.datetime.now()
+ print("Start time: ", now.strftime('%H:%M:%S'))
+
+ if model == "regression":
+ print('\x1b[1;42m','Regression','\x1b[0m')
+ y_rf = RandomForestRegressor(n_estimators=100, max_depth=2, random_state=0)
+ e_rf = RandomForestRegressor(n_estimators=100, max_depth=2, random_state=0)
+ else:
+ print('\x1b[1;42m','Classification','\x1b[0m')
+ y_rf = RandomForestClassifier(n_estimators=100, max_depth=2, random_state=0)
+ e_rf = RandomForestClassifier(n_estimators=100, max_depth=2, random_state=0)
+
+ # a list of numbered clusters
+ nc = list(cluster_info.values())
+ num_clusters = list(range(max(nc)))
+
+ # extract information from dictionary by inversion
+ inv_cluster_info = dict()
+ for k, v in cluster_info.items():
+ inv_cluster_info.setdefault(v, list()).append(k)
+
+ # an ordered list of features in each cluster
+ cluster = list(dict(sorted(inv_cluster_info.items())).values())
+
+ # fill the interation bank with random models
+ # models contain 1-component number of features
+ # ensure the models are not duplicated and non redundant
+ index_sort_bank = set()
+ model_bank = [ ini_desc for _ in range(bank) for ini_desc in [sorted([random.choice(cluster[random.choice(num_clusters)]) for _ in range(random.randint(1,component))])] if ini_desc not in tuple(index_sort_bank) and not index_sort_bank.add(tuple(ini_desc))]
+
+ # score each set of features, saving each score and the corresponding feature set
+ scoring_bank = list(map(lambda x: [y_rf.fit(np.array(X_data.loc[:,x]), y_data.values.ravel()).score(np.array(X_data.loc[:,x]), y_data), list(X_data.loc[:,x].columns.values)], model_bank))
+
+ def evolve(i):
+ """
+ Evolution of descriptors for learning algorithm, implemented as a function map
+
+ Parameters
+ ----------
+ i: list, descriptor set
+ """
+ i = i[1]
+ group_n = [cluster_info[x]-1 for x in i]
+ sw_index = random.randrange(0, len(i))
+ sw_group = random.randrange(0, max(nc))
+ while sw_group in group_n:
+ sw_group = random.randrange(0, max(nc))
+ b_set = [random.choice(cluster[sw_group]) if x == sw_index else i[x] for x in range(0, len(i))]
+ b_set.sort()
+ x = X_data[b_set].values
+ y = y_data.values.ravel()
+ score = e_rf.fit(x, y).score(x, y)
+ return [score, b_set]
+
+ # perform main learning loop
+ for n in range(learning):
+ # initialize best score to the worst possible score
+ best_score = -float("inf")
+ # Evolve the bank of models and allow those surpassing the best score to replace the worst models up to the bank size
+ rank_filter = filter(lambda x, best_score=best_score: x[0] > best_score and (best_score := x[0]), map(evolve, scoring_bank))
+ scoring_bank = sorted(itertools.chain(scoring_bank, rank_filter), reverse = True)[:bank]
+ if n % interval == 0 and n != 0:
+ tt = datetime.datetime.now()
+ print(n, '=>', tt.strftime('%H:%M:%S'), scoring_bank[0])
+
+ # print output and return best model found during training
+ print("Best score: ", scoring_bank[0][0])
+ clulog = [cluster_info[y] for y in scoring_bank[0][1]]
+ print("Model's cluster info", clulog)
+ fi = datetime.datetime.now()
+ fiTime = fi.strftime('%H:%M:%S')
+ print("Finish Time : ", fiTime)
+ return scoring_bank[0][1]
diff --git a/qsar_scoring.py b/src/qsar_scoring.py
similarity index 92%
rename from qsar_scoring.py
rename to src/qsar_scoring.py
index 17ea6b3..d6f3612 100644
--- a/qsar_scoring.py
+++ b/src/qsar_scoring.py
@@ -5,7 +5,7 @@
"""
Copyright (C) 2023 Stephen Szwiec
-This file is part of pyqsarplus.
+This file is part of qsarify.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@@ -60,15 +60,14 @@ def q2_score(y_true, y_pred):
def q2f_score(y_true, y_pred, y_mean):
"""
- Calculates the Q2_f1 or Q2_f2 score
+ Calculates the Q2_f1 or Q2_f2 score
depending on whether the mean is calculated from the training set or the external set
Parameters
----------
y_true : numpy array, shape (n_samples,)
y_pred : numpy array, shape (n_samples,)
- y_mean : float
- mean of the training set
+ y_mean : float, mean of the training (for q2f1) or test (for q2f2) set
Returns
-------
@@ -96,7 +95,6 @@ def q2f3_score(y_true, y_pred, n_train, n_external):
float
"""
press = np.sum(np.square(y_true - y_pred))
- # create a sum of the squared differences between the true values and mean value, using a map function
tss = np.sum(np.square(y_true - np.mean(y_true)))
return 1 - (press / n_external) / (tss * n_train)
+ 
+ 
+ 