import pandas as pd
from pandas_profiling import ProfileReport
heart = pd.read_csv('../data/raw/heart.csv', index_col=0)
profile = ProfileReport(heart, title='Heart report', explorative=True)
profile.to_file('../reports/heart_report.html')
# First, as we normally do, we are going to import pandas and numpy
import numpy as np
import pandas as pd
# Thats where we import the function that will generate the ProfileReport
from pandas_profiling import ProfileReport
# Loads the dataset with the admission probability of various students and their
# scores in different tests of knowledge
df = pd.read_csv("Admission_Predict_Ver1.1.csv", encoding='unicode_escape')
# Here is the function that generates the report using Pandas-Profiling
profile = ProfileReport(df,
title='Graduate Admission',
html={'style': {
'full_width': True
}})
profile.to_notebook_iframe()
# Hint! If you were using a large dataset, set the minimal named argument to True
# profile = ProfileReport(large_dataset, minimal=True)
# It is also recommended to open the report as a html file, in this way Jupyter-Notebook
# does not becames laggy because of the big Jupyter-Notebook cell
profile.to_file(output_file="largeDatasetProfileReport.html")
# The profile report can also be saved as json, just change the file extension in the
# to_file() call
profile.to_file(output_file="largeDatasetProfileReport.json")
contf = pd.DataFrame(
data=scale(quantile_transform(
X=X.filter(like='cont'),
output_distribution='normal',
random_state=0
)),
columns=X.filter(like='cont').columns,
index=X.index
)
LOGGER.info('Make raw X and profile')
X = catf.join(contf)
del catf, contf
ProfileReport(
df=X.join(y),
minimal=True,
title='Data with minimum preprocessing',
progress_bar=False
).to_file(p.joinpath('reports', 'profiles', 'raw.html'))
LOGGER.info('Create ranking')
ranking = Ranker().rank(X, y)
LOGGER.info('Figure 4: Volcano plot for features')
fig, ax = plt.subplots(figsize=A4_DIMS)
ax = sns.scatterplot(
x=ranking['Statistical Significance'],
y=ranking['Association Strength'],
s=100,
)
ax.set(
title='Figure 4: Volcano plot for features',
def exec_sql_multiple_sites():
empty_df = pd.DataFrame(data={'': ['No data available.']})
error_df = pd.DataFrame()
config_flag = input(
f'\nDo you have a config file you want to use? Please enter Y/N only:')
sites = []
if config_flag == 'Y':
config_path = input(
f'\nPlease enter the full path to your config file: ')
usr, pwd, input_f, write_out, output_folder, output_file, all_sites, individual, sites, rule_folder = read_config(
config_path)
else:
confirm = 'N'
while (confirm != 'Y'):
usr, pwd, input_f, write_out, output_folder, output_file, all_sites, individual, sites, rule_folder = gather_input(
)
confirm = input(
f'\nPlease confirm all your inputs are correct. (Enter Y/N only): '
)
if (all_sites == 'Y' and sites):
print(
'You can\'t answer \'Y\' to run all sites and enter site lists at the same time. Conflicting values. Please review your config file and run again.'
)
quit()
location_df, site_lists, site_locations = get_all_sites(usr, pwd)
output_folder = Path(''.join([
output_folder, '/',
dt.datetime.now().strftime("%y-%m-%d %H%M%S"), '/'
]))
output_folder.mkdir(parents=True, exist_ok=True)
final_df = pd.DataFrame()
outcome_final_df = pd.DataFrame()
if (all_sites == 'Y'): sites = site_lists
if (all_sites == 'N' and not sites):
for s in site_lists:
s_name = location_df[location_df['locationid'] ==
s]['reportname'].item()
region = location_df[location_df['locationid'] ==
s]['region'].item()
confirm_site = input('Do you want to run for ' + s_name +
'? (Y/N only): ')
if (confirm_site == 'Y'): sites.append(s)
else: print('Skipping ' + s_name)
for s in sites:
s = int(s)
s_name = location_df[location_df['locationid'] ==
s]['reportname'].item()
region = location_df[location_df['locationid'] == s]['region'].item()
outcome_df = pd.DataFrame()
try:
df, rule_df = exec_sql(usr, pwd, s, location_df, input_f,
rule_folder)
convert_date(df, [
'lot_expiration', 'rx_date_received', 'order_date',
'date_entered', 'expire_date', 'date_last_adjudicated',
'fillcalendardate', 'fill_date', 'date_verified', 'delivered'
])
collist = [col for col in df.columns if "_CHECK" in col]
if len(rule_df) > 0:
outcome_df = check_column(df, rule_df, collist)
outcome_df['site'] = s_name
outcome_df['region'] = region
outcome_final_df = outcome_final_df.append(outcome_df)
else:
outcome_df['site'] = s_name
outcome_df['region'] = region
outcome_df[''] = 'No rule engine defined'
outcome_final_df = outcome_final_df.append(outcome_df)
for col in collist:
df.drop(columns=col, inplace=True)
if (len(df) == 0):
df = empty_df
df['site'] = s_name
df['region'] = region
if (individual == 'N'):
final_df = final_df.append(df)
else:
individual_file = s_name + '-' + output_file
out_file = str(
output_folder) + '\\' + individual_file + '.html'
ProfileReport(df,
minimal=True,
samples=None,
reject_variables=False,
correlations=None,
missing_diagrams=None,
duplicates=None,
interactions=None).to_file(output_file=out_file)
except Exception as e:
print(f'\nError with ' + s_name +
'. Please check the error log at the end of the run.')
err = str(e)
err_df = pd.DataFrame(data={
'Locaton': [s_name],
'ErrorMsg': [err]
})
error_df = error_df.append(err_df)
if (individual == 'N'):
ProfileReport(final_df,
minimal=True,
samples=None,
reject_variables=False,
correlations=None,
missing_diagrams=None,
duplicates=None,
interactions=None).to_file(output_file=out_file)
outcome_final_df.to_excel(
str(Path(output_folder / 'Quality Check Outcome-All Sites-')) +
str(dt.date.today()) + '.xlsx',
index=False)
if (len(error_df) > 0):
error_df.to_csv(str(Path(output_folder / 'ErrorLog-')) +
str(dt.date.today()) + '.csv',
sep='|',
index=False)
shutil.copy(src=input_f, dst=str(output_folder))
if config_flag == 'Y':
shutil.copy(src=config_path, dst=str(output_folder))
#if rule_folder != '':
# shutil.copy(src = str(Path(Path(rule_folder)/'Custom Rule Engine.xlsx')), dst = str(output_folder))
del df
del final_df
gc.collect()
return print('The run completed.')
import pandas as pd
import numpy as np
from pandas_profiling import ProfileReport
import matplotlib.pyplot as plt
import RFMScore
import Aggregating_RFMScore_CAH
#################################################################################
####################### Import data ##################################
#################################################################################
df = pd.read_excel('./data/HotelCustomersDataset.xlsx')
#################################################################################
####################### Univariate analysis ##########################
#################################################################################
profile = ProfileReport(df, title="Pandas Profiling Report")
profile.to_file("./results/univariate_report.html")
rfm = RFMScore.create_RFMScore(df)
# Get the number of customers for each segment
rfm.groupby(['RFMScore'])['DocIDHash'].nunique().reset_index().rename(
columns={'DocIDHash': 'Nb Customers'})
################################################################
# Create segments by aggregating RFM SCores
################################################################
# First we download the segments names by RFM Score
segments_names = pd.read_csv('./results/segments.csv')
rfm = pd.merge(rfm,
segments_names,
import pandas as pd
import numpy as np
from pandas_profiling import ProfileReport
df = pd.read_csv(
"https://raw.githubusercontent.com/owid/covid-19-data/master/public/data/owid-covid-data.csv",
error_bad_lines=False)
profile = ProfileReport(df, title='Pandas Profiling Report', explorative=True)
profile.to_file("../webpages/your_report.html")
pop["State"] = pop["State"].apply(lambda x: x.replace("?owa", "Iowa"))
pop["State"] = pop["State"].apply(lambda x: x.replace("Louisianaa", "Louisiana"))
pop["State"] = pop["State"].apply(lambda x: x.replace("C0lorado", "Colorado"))
pop = pop.apply(lambda x: x.str.strip() if x.dtype == "object" else x)
pop['State'] = pop['State'].replace(['?est Virginia','?ew York','?outh Dakota','?orth Carolina','?hode Island','?ew Jersey','?ew Mexico','?ew Hampshire','?orth Dakota','?outh Carolina','COlorado']
,['West Virginia','New York','South Dakota','North Carolina','Rhode Island','New Jersey','New Mexico','New Hampshire','North Dakota','South Carolina','Colorado'])
pop['State'].nunique()
! pip install pandas==0.25
from pandas_profiling import ProfileReport
profile = ProfileReport(pop)
profile
pop.describe()
# Summarize data by City and sum of ten Year Population Growth
pop.groupby('City').sum()
# Summarize data by City and median of Ten year Population Growth
pop.groupby('State').median()
# Group data by state and summarize 2019_Population
grp_state = pop.groupby(["State"])[["2019_Population"]].describe()
grp_state
grp_state.columns = grp_state.columns.droplevel(0)
def profilling(df):
pr = ProfileReport(df, explorative=True)
st_profile_report(pr)
# +
df_videos = pd.read_csv(os.path.join('..', 'data',
'AIcia_videos_20210410.csv'))
df_videos['公開日時'] = pd.to_datetime(df_videos['公開日時'])
df_videos['動画時間_s'] = pd.to_timedelta(
df_videos['動画時間']).apply(lambda x: x.seconds)
df_videos = df_videos.drop(['動画時間'], axis=1)
df_videos.head()
# -
profile = ProfileReport(df_videos,
title='Pandas Profiling Report',
html={'style': {
'full_width': True
}})
profile
# # Hierarchical Bayesian Modeling
n_videos = len(df_videos)
# +
# define model and sample
with pm.Model() as model:
# prior to parameters
alpha_plus = pm.Normal('alpha_plus', mu=-3, sd=2)
# As not all datasets have an index of files, we generate that ourselves.
files = [f for f in p.rglob("*") if f.is_file()]
series = pd.Series(files, name="files")
# PP only accepts absolute paths
series = series.apply(lambda x: x.absolute()).apply(str)
df = pd.DataFrame(series)
# Generate the profile report
profile = ProfileReport(
df,
title="Example showcasing EXIF data (Kaggle 5 Celebrity Faces Dataset)",
# Disable what's not in our focus
duplicates=None,
correlations=None,
samples=None,
missing_diagrams=None,
# Enable files and images (off by default, as it uses relatively expensive computations when not interested)
explorative=True,
)
# We can also configure the report like this
profile.set_variable(
"variables.descriptions",
{
"files": "The 5 Celebrity Faces Dataset found on Kaggle (dansbecker/5-celebrity-faces-dataset)."
},
)
# Save the report
profile.to_file("celebrity-faces.html")
import pandas as pd from pandas_profiling import ProfileReport ### File 1/9: nacional_covid19.csv ### PATH_TO_FILE = "nacional_covid19.csv" FINAL_FILE_NAME = "nacional_covid19" FINAL_HTML_PATH = "../webpages/COVID-19-in-Spain-Dataset/" + FINAL_FILE_NAME + ".html" df1 = pd.read_csv(PATH_TO_FILE, error_bad_lines=False) print(df1.info()) profile = ProfileReport(df1, title=FINAL_FILE_NAME, explorative=True) profile.to_file(FINAL_HTML_PATH) ### File 2/9: nacional_covid19_rango_edad.csv ### PATH_TO_FILE = "nacional_covid19_rango_edad.csv" FINAL_FILE_NAME = "nacional_covid19_rango_edad" FINAL_HTML_PATH = "../webpages/COVID-19-in-Spain-Dataset/" + FINAL_FILE_NAME + ".html" df2 = pd.read_csv(PATH_TO_FILE, error_bad_lines=False) print(df2.info()) profile = ProfileReport(df2, title=FINAL_FILE_NAME, explorative=True) profile.to_file(FINAL_HTML_PATH) ### File 3/9: ccaa_camas_uci_2017.csv ### PATH_TO_FILE = "ccaa_camas_uci_2017.csv" FINAL_FILE_NAME = "ccaa_camas_uci_2017" FINAL_HTML_PATH = "../webpages/COVID-19-in-Spain-Dataset/" + FINAL_FILE_NAME + ".html"
# ### Read train and test datasets
# In[2]:
sample_submission = pd.read_csv("C:/Users/User/Desktop/ML Projects/housing_prices/dataset/sample_submission.csv")
test = pd.read_csv("C:/Users/User/Desktop/ML Projects/housing_prices/dataset/test.csv")
train = pd.read_csv("C:/Users/User/Desktop/ML Projects/housing_prices/dataset/train.csv")
# In[3]:
train_profile = ProfileReport(train)
train_profile
# In[4]:
# Describe dataset
print("Train set has {} rows and {} columns.".format(train.shape[0], train.shape[1]))
print("Test set has {} rows and {} columns.".format(test.shape[0], test.shape[1]))
# Information about dataset
train_stats = train.describe().T
# Understand each features datatype
train.dtypes
# Display no. of numerical and categorical data types
import pandas as pd
from pandas_profiling import ProfileReport
data = pd.read_csv('Assignment2.csv')
profile = ProfileReport(data)
profile.to_file('report.html')
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.feature_selection import VarianceThreshold
##Loading the model file
loaded_model = pickle.load(open('Best_classifier.pckl', 'rb'))
#Read Test set file
data_read_test=pd.read_csv("test_set.csv")
#See the basic stats of the model
data_read_test.head()
data_read_test = data_read_test.drop(data_read_test.columns[0],axis='columns')
data_read_test.info()
data_read_test.describe()
#optional profiling
profile = ProfileReport(data_read_test, title="Pandas Profiling Report")
#profile
#
data_read_test=data_read_test.drop('X32',axis='columns')
#Getting the shape of dataframe
print("shape of the data:", data_read_test.shape)
#We don't need to encode into numerical as all the columns are numerical
X = data_read_test
#Checking the variance again in the dataset
sel_variance_threshold = VarianceThreshold()
X_train_remove_variance = sel_variance_threshold.fit_transform(X)
print(X_train_remove_variance.shape)
# Example: Constant variable
df["source"] = "NASA"
# Example: Boolean variable
df["boolean"] = np.random.choice([True, False], df.shape[0])
# Example: Mixed with base types
df["mixed"] = np.random.choice([1, "A"], df.shape[0])
# Example: Unhashable
df["unhashable"] = [[1]] * df.shape[0]
# Example: Highly correlated variables
df["reclat_city"] = df["reclat"] + np.random.normal(scale=5, size=(len(df)))
# Example: Duplicate observations
duplicates_to_add = pd.DataFrame(df.iloc[0:10].copy())
df = df.append(duplicates_to_add, ignore_index=True)
logo_string = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAjoAAAHCCAYAAADmYWMpAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAZlZJREFUeNrsvX+QVdW597kaKfAdfpoxEyy4dBsh94oD6a6aRK9Fk+ZNSNmhGVGjBcJMGu5UQXSk5c5NFHxzhUkJYu470lga+eNCOyXiK4rkpbGZaGJLc72ae9/qvpjglGBseqDsRCvhl6mgV5j93b1Xs3uffc7ZP9bee629v5+q42ka6T5n7X32+u7n+T7PIwQhhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQYi41XAJC8s+4xvamGP/89Cc9bX1cRUIIhQ4hJEmxMtl6qnf+iOfJztdfdX3t/n+Sptv1db/1OOH6ut/5us8SSad59AghFDqEUMjUWU91LhEjBYz8vsn0ux4nXF9TCBFCKHQIyZmgqXcJmq+6vi4y3S4RZH9tCaB+ni2EEAodQvQWNU0uQVNPQRNJAPU5AgjRn24uCSGEQoeQbEQNREwTRU3i9DkC6N/wzMgPIYRCh5BkhE2TI2y+4TyTbDjtCJ83HOHDCjFCCIUOIRQ2FD6EEAodQoosbOqsp8UuYTOZq2Ks8NnnCJ99rPIihEKHkCKLGwiaWx2BU8cVySWI8PzMET2M9hBCoUNIroUNojRuccOoTbHoF0Nprp9Zomcfl4MQCh1C8iJuFrvEDSFAprgoegih0CHESIEjxU0rV4MEFD3PsHcPIRQ6hOgsbpqsp+8JpqVIdPod0dPOnj2EUOgQooO4qRNDURsInDquCFEIzMvtgtVbhFDoEJKBwFksLkdvCEmaDsHUFiEUOoQkLG7qBKM3sbj3znrRWD9NPHvwqOjs+S0XJDz9YijK08EoDyEUOoSoEjhN1lObYPQmtsjZct+84T/fcFeHODF4lgsTDWlg3kgvDyH6MIpLQAwTOK3W4wPry9cpcuIzafzYEX+efs1ELkp0YHZvtR4fWOfo604qlZDC8e+N1zbp9HoY0SEmiBtsIPeLoQgOK6cUMmfGF0XXttttwXPk+Efi5pW7uShq6RdDEZ4OLgUpiMipt56+N7rng7UUOoRUFzh11tPDgqXhiQKRUztloi10SGIgrQUfz1b6eEiORQ6u073WY60ldLRpukmhQ3QWOK1cDULBQ4gxQgeWgnpL5Fyl0+ui0CEUOIRkQ4egcZnkR+Q8LoYsBlt1SltR6BAKHEIoeAiJK3Jw7d7p/LHBEjp9FDqEUOAQ4oYpLWKqyIH5uNf5Y58lchp0e40UOiQLgQPD2uMUOIRQ8BCjRU6dI3JksQhMyFspdEjRBQ7LxAkJJnjWsiydaCxycA23zceub19lCR3tBDqFDklL5LSKoSgOBQ4hwem3His4T4toKHReFiObtnZYImeFjq+VQockLXCaxJBJrY6rQUhkIHQQ4enjUhANRA6u6a2eb8+3hI6WgpxChyQlcCBsHhcc00CISuB/2Ej/DslQ5LSKyxVWEi1NyBQ6JCmBI304D3M1CEmE047Y2cqlIBqIHLDCEjodFDqkCCIH0RtEceq4GiQJWhq/LDp7fsuFcO6ixZB/h+kskobIgekY5mOvz/K0bp2QvXB6OVEhcOqsB4xpL1PkkCTBEFIyjN2/xPrsPe5EUglJW+SAdt1fP4UOiStykKZCHwV6cQjFTjbgM/iBE1ElRLXImezcxJYT09qnUEfzMJKIAgcKf6cY2UOBkMSZNGEsF6EUezOyPpeYGL2CZmWiUOQgklNX5n/p0LFvjhdGdEgUkbNBDEVxKHJI+kJn/BguQnkQ1fnAibQSEpfXq1znN5rwJhjRIWEEDqM4JFMaG6ZZQmcsDcmVsUesWJ/XW8VQdKefS0LC4vTKqXStRzTHiHOLER0SVORsEIzikIyAuOnadodorJ8q7r2zXry5Y6n9PVKRJjFkVqZ3h0QROa1V/rd2U94Py8tJNYFTJ4aMaBQ4JDPWr7jRfrjZ1fWuWLX5VS5OMOjdISpFTvfong/mU+iQPIgc2fiPpasGgGqk5zctFNOnTBQ9fafEkvWd4sz5C0a9B6SmELUBtdb7mH7NROe9XV02goP32NN7Shw5/pH9Z6S15NdkBBA5t3FuFqkgcjaIYM1etR33QKFDggocCBuoeoa8DeLoC622yJFgw1/yUKfx4g1VVstvuV4sa75+xN/l4f1lxFZL7KzlMhCPyGkV/l2PvRgVzaHQIX4ip0lwCKeRnD+0puR74+dty8V7G/Lo3D7cQ2dg8KxoXrNXnLCeSSTYVZlEETnAqGgOoBmZuEXOBlG5ZwLRGG+aKonKJPhkYAp+/pGWVBv34b3dvHK37cvBY9ZdHRQ58bA73Vqf+VYuBUVOCJHTbZrIASwvJzJVBcNxE1fDXBDhcHt0Nu18W+nPR7WT2xDc2DDVFhxp+oAobpRip6itz/83rOe1NCpT5ATAyJQnhQ5FTqUZJsQgYMCF8EiKlsbrRvwZ6aQ5M78oenpPpvoeOQJCOdjs6q1rwW3suUORUwH0zTEy1cnUVbFFjpxTRZFDqjLwYWk05cy5dKu6zpz/1LhKMkOQA0JZgECRU46Npr5fCp1iCpzJ1gMn+eNcDRIUpMIGXKmjJ/f0ZVLGfeT4xzwYySDnZW3gUlDkeDCmC7IfrLoqnsipE2wASGKAXjeI7mTll8HvTzNdVlDYYJAiR4Jz4FoThndS6BBZOv6yYKqKGAy8QUxfpQJL0ClywEZL5Gww+b0zdVUckYOTnKZjYjwUOakhS9CbuBSFFTn91mOr6e+fQqcYImdnxJOcEFJsJgv22ymqyAEbTU5ZSZi6yrfA4SgHQogqOj7paVvBZTBK5KDg5P6I/9y4UQ8UOsUUOUhV0XRMCFEFTcrmiJwgU8gr0WBq3xwvTF3lU+RA3HxAkUMIUQyiw687N1IkvyKnIy8iBzCik0+RQ9MxISRJ+q3HbazI0k7g4Lr/eEyRY3w5uRdGdPIlcnBys9MxISRp6sRQZIdRY71EzusxRQ7YmCeRAxjRyZfIYWUVISRNsCEistPNpdBC5MQVnrkxILthRCcfIud+ihw9aWn8sujadod4/pEWUTtlYmavA797efP1HIhJVMPy8+xFjj2nTKjxZK7N4xoxomO+yIlrOiMJcuqVVXYnX9DZ81ux5KHOTETOmzuWDr+O5ra9HKFAkgDVWB1chtRFjipPpvEdkMvBiA5FDkkQKS6yZPo1E0e8jsb6qTwwJAl2MrKTqshpVShy+kUOOiBT6FDkkAx44IlD9jOmfmP6txQ/GEyZVioLAzjdYxN6+k7xwBCKHfNFzk6hrvBkRd4MyG6YuqLIISkCkXP0hdbU00gQVcuar7dFDtNWJAWYxkpO5Ki+/m+1RM7aPK8ZIzoUOSRF5sz8YiZppBNORIkih6QEIzvqBc5k6/Gy4ut/v/XYmPe1o9ChyCEpwjQSodghUUSOGPLjqJ5bmOuUlYSpK4ockjJ+aSSUfi9rniXOnLtgR16OHP+IC0XyAtNY8UROUt3uc5+yotChyCEaoUMZOiEUO9qJHFz3H09A5PSLoaGdhRjOytQVRQ7RAB3K0AlJEKaxwoucDUJtZdUI4VkUkUOhQ5FDNGH15ldt7467DF1XUBqPByEUO4kInMlOZdXDCf0KpKy6i7SmTF3pK3JaBcc6EM3Yct88ce+dQ53mmWIjUaMJTGOVFTl11hMqq5Ialopp8/OLFM0BjOhQ5BASGJTHSzDHi5AIPM6p574ip0mom1lVVmQWTeRQ6FDkEBKKI8cuV4OxNJ5ERA4Cpdi5LHIwmDmJyio3ay2R01fE9WXqSi+RU5/CyU4yAFPDt6yZl4vycZTCwzz9bNe7I3oCERISRBau/aSn7XRRF8Dpj4OqqtaEf1W3JXLmF3WdKXQocnIBNl6ZVqnWbVhGItC8Dx2D0wBjH6Y7s63obSFkGNszUkSx4/THQfQ+6ciWLSiLmLKSjObnTAuRA3HzMkVOcOAPQZQE1T9zZlwdqzwb0ZUz5z+1m/fh63eOfaxcALlf36QJLCUnxEHe4DUUTOQsFsmVjnu5rcgiBzCio4fIeT0FVW88SJm0zL0uFRMsyryPWIKnp++kJYBOxU414bU/vW6BnepZtflVO6pDCBmm45OethUFETlIVd2f0q/baImcDUU/uSh0shc67JVTATkuASXNWTbVg/CB4Nl/+H2KFEIS2pQtsZPbTdk1ryqtm9pC+3IodPQROfhQP8yVKAWiBuJm/YobtXttiMpA9HRaogeGXEKIMnLZY8cpHU/TnlB4Xw6Fjh4ip1WwjNwXpKa2r1sQKoIjB2Qi8nJi8FxFo7HbuAx/D0zC+HMUrw9EDyI8zx58d3hAJyEk1gYNc3JuyqCdUQ5p39DOL1r3Ywod/UQOK6zKCBAInCAeHAia/ZbA6Dz8W6UCA6my2TOvFo31GHMw1TY8BwWvCRGeXdYjrWouQnIqdowvO0+hy3E50C9nK08jCp0sRQ7EzQcUOSOBoHh+08LhEuxyIHLz5J7e1HwyEF8QPIvmXmc/V3t9EogdRnkIiUyfJXSMrcRKuarKzT5L5NzG04dCJ2uhk3SLbyNFTte22yumjSBw0Ggva+GA1wpz9KLGLwcSPXJIJ708hITGuEosx3CMNNX9Gfz6Qs6xotDRT+SwwiqkyIEH5oEnDmkpFPDaYZhGqq2at0emtZ7c08duwoQExxhzcooNAP047YicPp4yFDpZipxWQfNxKJGD3jVL1x8wwu+CPjnLmmdV7coMkQOxQ8FDSGAadDcnO7OqHs/wJaAp4D6eKhQ6WYocmo89QNxgLEI5kQOPCxrrmQbMzCiJrxbloeAhJDD9jtjRLiXjpKpgOG7K8GWwKWAVruASJC5y5AehjqtxmX3/sFh8ZfpVuRI5UsCgEuwff/Zr8fs//En8Ze1VvoLnyjGj7fEV/9uts+2vjxz/WFz49HOeGISUgmvoTZ8NHHxGM5Gz2LmB/asMX0aHJXLW8hSpDCM6yQsdiJzFXInLIOJRrhGgySKnHEhr4f1WMi9DIMG0jAgPqXzuQCDmYQo8CR+50KFzshPF2anBdZ3mYwodLURO1nlb7UBq5zcvtPr+Xd6negcRPKzSCi6QIQ5n3dXB1F+xQDPB7gxFTpMjcuoyXgeImwZL5PTzlKjOKC5BYiIHvhyOd/Dw9PoFZTf4vEVyvEC8YGNebb3PgTIGa4ggDP/s2naHHbkgl/Guh7vDNSkMOx07QNoCZ7IzjPN1TUTOfIocCp2sRY4MbdJ87NmoylUlLVl/oDB35kEED9apq/320KMw8gzSVSUC+UN2oC4YdSLl6lUnioP+Z/drsgZrWUYeDpqRE2BMbfNmQV9OCdvXL7BTV16Qqnnxl+8Vbj1gQJaeHEQmYEr2gu/DsAyj8r8cHSz0+fPewB/Fghtrh4UfzhsYv0nh+CvrGnvms4GDbyUscCb/fe1VuJY/rdFN60aOdwgPPTqKGdfYDoHzMlfCE6FomGZHKEruyAfPir9eubvwPgts3vCfoAFheWH0kXjgiZ7Cj5XAuVRpaCspBIkO/9TIi+MGFVYreOgpdLIWOZxjVQakYDA6wQvSNzTeXgYRL/iYKjUeRBQI0QyacEnBUT4PK+MRDpXotkTOfB7yaNCjoxb6cnxAtMJP5MixCOQyiFI0r3lJNLftLevfQdQHzRaDTHknJMfUWzeXGxSKnMXOjapuIgdRKw7qpNDJHmfEA305PiwqsyEjKkH8QXoKhuVyawTx+PwjLfaDZmVSYB52KlzjCBxUVMFu8LKGN6qywoq9cih0Mhc5dYL9csrSMve6ku8h7bK/h0bSakDo3GAJHkxv911bS0QiulPJ20NIzolccu7MqPpA05tUihwKHb0+aIIpq7KRB78UC5oD0mMSDJnOgp/Jb82wxlvum8foDikqoXuWWQKnznq87tyg6nrt5jRyCh09cLofN3El/Gls8DfVmjTqQBfxIPvvdJaJhMnoDr07pIDcHzSFZQmcDWIoiqPzdXsFRQ6Fji4iZ7Jg9+PKQqe+tLsvohImzSha7mOkzgqsHcZk4FEuukPvDikoO6sInCbr8YEB12yInA4eTgodnT5YTFlVEjo+EZ1Ow7w5OgoGrGG16M4/71jKMRKkSPhWYbnMxjqMb6jGWoocCh1tcBoDssqqCnNmlM4i6ulT3/AO/WewqRcpilEtuoO5WWjSWG5SPCE55GGnOESKHJ3Nxl462PWYQkcnkYMoDqusqlAumtDTe0q5yHlzx1J7U4dHRaXYsedzaR4VkdGdcpVZEDpYn9oKU9MJyRE7nTRVr9DbbOwVOex6TKGj112D0D8EmjlzZlxd8j00wVPduh/NCKW4KepEa0R0UJn1wBOHfKM7iKxB7NCoTPLMJHFB/FT8vEkMpalM6blAkUOhoxeOs/9+rkSAi45PZOXIsY+V/x5vJEPlRGuMYqidMsEYrwuq2ZrX7PU1e0ujMkrRCckb3xe94h2xQ9wtjpr0svdR5CQPp5eHZExt827BaE4g1q+8qSRdginl5VIsUUGUCBs7pltv6viVsoouiIK/uXW2LRCWO1Gj1351Qvt1/90f/iT+8We/tl/v12+YUvL3+B4iO6+9PcBeRsR45oqT4jmxXyyzBM6V4nOTXro92uH/HDj9Zx5FCh1tcMY8MJoTkOXNs0qEzpMv9tmCRDX4mRBQA4rSYhA2f7vsfyoRCPgdtddMFJMtEQFBoTMQZRB9C26sFVeOGT3i7770hXH2e8S6JXE8CEma6eKseFS8YT++JP5k2suHyGHX45Tg9PLgIoeTyUNy/tCaku9hWCXmOOkChJgcOAofy6QJY+1U1fQyxl0ZjTpz7nIvIDzrXDKP97h700LfCjhbfO7ps709hJjCOvGWnaqCJ8dAKHIodLQVOhsEmwPGFjpTv7PdiHQJ0j7eCi5Ei1DdZCrw5pSbiQUBt2R9J1NZRGsWivftCA6iOYZCkZMBNCMHEzl1FDlqMGUjxetctfnV4VTYkBA4YPTaI2pTbl4WTNdoMFgu6kNIlswWH4kD4kXbi0ORQyh0koE9c0Lit2GaFi1AOgoVTACl2yaNrSgH5mWVq8qyGwxuu12rkRek2Djl4uKw2GWbjg2GIodCR1/GNbY3CXZADn+BmuBTWn7840xeCzZupNHwCLuJn3AquvIE3g/Ejp+vCKm6p9ctYAk6yVzgwIdjYLk4RQ6FjpEwmmM47hEIUTbwM+c/zd2ayPERm3a+7fv38PJwMCjJAggbRHAetISOoWZjihwKHXNwysnruRJm425SGKUr85FjH+V2bSB0ys3KQq8dpLI4OoKkAVJTiOAgVWWwD4cih0LHOGhAzgEw4e7qetdO1aze9Frof5/3SiTpRfJL0cnRETQpkyQFDozGeORE4FDkUOiYwbjGdjQGrONKmA+iOKigQuQib34bVUjfjl/XaqSvIHZoUiYqgahBFRUEjuFGY4oczWFnZH+Rg6aAL1uPK7ka0UD3YO/GODB4zo6smIbqkRW6cuHTz+3jg1SV32DUlsbrCrUeJDmBg144SFF9ReSuKzdFjoYwouMPojnsgEwKCaJf6LfjB4zd29ct4CKR0MhS8ZxUUvnRTZGjJ6O5BCNxojltXAlSZNBv5/T5C7ao8VZeYWTG9GsmspMyCSxw7hG9Jo9sCEIHp5DrCyM6pTCao4A8VyoVBWlSLtdJGRVZLD8nlQSO7IWTk1JxihwKHfNhNEcdvNPPiWA9/pE936tcRRbmgbEiixRU4FDkUOgYCaM5CYKp4MRM0VqpIguRHYodUjCBA7ZS5FDoGAWjOckznY3nDBc7L/lWzUmxgwaDhAKnAAIHrLBEzloefQod02A0RzEsQ84fqMh6ck+fr9jByAj22qHAKYjI6eAZQKFjIt/jEiQPxwmYDzpNlys/x0BQih0KnJxymiLHTNgwUAzPtGrlSqhlXv20ksZznYd/KwYGz3JxDAeT6HEcZRNBN2wsmF+B87fiXy150yW+JU6IK8XnRXr7EDnokXOQZ4J5sI/OEJxplQB+AzQnjR/DhckJlXrtoLEgonerykR+iFkCpwB9cIKInD6eDWZS+NTVuMb2xYIzrRLBL3LD6px8UanXDhoLsouyuWBUAzoZD1j/LViKyg3EzbUUORQ6psNKq4Q4MXiu9O6QDeZyhxwISrGTL4GT41ENYUQORzpQ6JjNuMb2euupiadBMgx86BPRmcmIDsUO0RFMEKfAGaaDIic/FN2jw2hOgvh5dNg0MN9i5+aVu8XuTQtLUpTLnEosenb0FDioosIzGRI5bASYLwob0XEaBLbyFEgWb+UNmwbmX9wisuM3MoKRHb1A1OaAeNF+UOQM8UPR1E+RQ6GTJ+7n4U8ev/RVY8M0LkyOkSMjKHb0FThITyFNRYHjnLNirPi++LbYLurrnAIVQqGTC9ggMKU7fC9MX1HsUOyki7vJHwQODMfksshZKL4rnhOzuDdQ6OQHlpSnh1/TuNksMafYodhJBQiaR8Ubw12MKXBG8o74oi1y8OxisbVHcH+g0DEeKvaUOHKsdJNj5RXFDsVO8gJHVlDlsdEfojAJiRwJC1UodMzFUerMwaa40XlLjhvrp3JhKHYodhIAnhuYi/NaIj4gJorDYlps4YY01VyxrJJgauXZRKFjMjyBU6antzR9xQ7JFDsUO+qQBuM8V1D9VDTY0Ze47+9RcZNtPK7CZGcGIqHQMRKmrVLGb3ObM/NqLgzFDsVODIpiMEYU526xSMwWH4mF4v1YPwsCZ7MldAJyK88yCh3joAk5G/wMyY31LDGn2KHYiYLbf5N3gzGiOBA5cRsaIkWFVJWrsioINCVT6BgJFXoG+BmSZzOiQ7FDsRMKbPTPif3D/ps8D9kcSlEtE7ssYYJ0HKI5cX9WGdNxVbHDM49CxxjYCTnbjc27qcGjwwGfFDvlxM69d9ZzkRwgag5bWz42/LipG+3PCzFWPCi+YQsTiBu87ziC7oC4zq6sQvorIqy+otAxCirzDPEzJDc2sPqq6GJn6foDvoNAt9w3Tyx35mMVEem/GRA/tdNUcSIapgBRAoGDdBV6/+B9xwFpKqS9Ypai1znDnwmFjhHQhJyl0Okrza/Tp0PkbCw/sfP0ugWFEzsQNNjgIXDgv8lzekqCaAuiLlKUID2H3j9xgOk4QGUV9w4KnfzgGMqaeLgzFDqM6JAyIH1VSey0NH4592sgB2wiVZPH/jflQKk3ojjojQNTddz0nM84BxUwG0ChYwQ8UTOmnE+nltPMSRWxA3NyHvsuIVqDyEURB2wiTTVbrLRLvYcqok7aIi+u6RgiB6JJMRz0SaFjBAw9agCjOqSa2Fny0IFSQTB+rOjadntuxI67PBxelCLNn3KnqaRBGGIPkZw4aTqImwrjHFTAil0KHX1x0lY0k+kgdOjTIVXF8EmxevOrZcWOyZV6Mj1VhPJwL4jaIE2FKI6MuOD9Q/BB7MUBaSqIHBXzryrAiA6FjtbwBNVmEyuN6BTBf0HC8WzXu7kRO97uxUVKT7mFiExTSaQfJ64fSbHpuBKTmb6i0NEZpq10uas7f6GkSzI2Lc69In5iZ9POt0u+j3MFYkd3vNVTRUpPSRC5gcCBEHFHW1T4cSJ2Oo4L01eGckWe35yTtnqUh1kfJlvCZsGNtSO+9+dPPxev/eoEF4eMAKIYZvU5M0cK4S99YZz9/c7Dv9XuNSNCAYGDKE4Ret/4IWdTPeoYjd3Aj7NTdIkrxeeRf77sdByjCWBU6j4bOLiFn0zzGJ3z99fEQ6zZ5kVDMgnBKieFtczTTwd/Pn3+gnjgiUOZv0ZEa+6xNvCi+W78BA7SU35RFqwLvDhxU1X42Smlqnzv09A88JOetj5+Mil0dIKhRs1AZc3A4Fkx3VVWLsvM0TyOEC8/tMQMZqN5U5wYE/GOdT4hzZUF6PeyzNq48z6WoRqI2qCb8VPWw88QLNN4cSNcEDgpp6r8gBWCQscwcpu6cmZbdfAQ6wdEztdvmDLybtASOf9ydJCLQ0q48Onn4sVfHLNTnkhbuWlpvM4Wz+8N/DGV14LIxN+Kf7U37pXiHfEV8cdCHxs5Xfw1UWetzGhfMYhOx3E8ShBP3xJLxC+s36EBUz4bONjOT6VZ5NmM3MTDqyd+ZebLCjzXiATY7M5fEKs3vZZZQ0EYaItuLnYjK6kwgLNcWTd8ShA5cfvjzLYlpTYFC3WO95NQ6GgB01aa0tnz25INi12SSTXKdU9Oquzc3blYRSl0HpAdjZFGKmcGxrphvSAI44BoUQr9caLAMnMKHW1o4uHVW+x4YU8dEkTs+BmQVYod6SkpYuficsjOw+6OxuXWDqXjcfoFQdjg9yBapCnf4CfRLHLp0YEz3np6kIdXY2qE+O43vzLiW1/67/878Y8/+zXXhlQROx/bUR1vmwL4d6ZYjyhl54hC3CHeG1EaHqcEOk8CB9EblIpXK+dG9CtuqgopKoicBOZVqeSvPhs4uJGfRHPIa0SniYdWb5i+InF4ck+f2OVTbQWv15b75gX+Oe7ojYrKoDwJHERwggzJVD3KQSM/TqWbaaavKHQyh6FFQ8SOF6avSFDQY8fbaRug7Hx5BXM7Nmb4bZBiwaPo/W+iChwpFOP6l5CqkqMcNPTjcI+h0NEWqm0D2H/4fd9NipCgLFnfaft2vCCq463EYvRGncABckhpnHVE9Aa/U4P+OGFp4lljDjV5e0PjGttxAr7OQ2sGp15ZVWIgvXnlbt/NixA/5Pwr73mE1Ohf37VdLDzfazf2o7DxFzjoZhzWE4M0FTw5cYC4qVSebgBXfdLTdppnkf7kMaJDpW0Qfukr9tQhYYAoXvLQgZLvQ/j8Ztu37E2ZImckKBMPG8EBqEBDui+uyIHAMSxVxb2GQkcrmDs1CJhKvSyn0CEh6ek9KTZtfqnk+zUzZolR637CBXKQjf6iVDahy3HcqeOo3MJATvTI4V5DKHSosgtzNz7gmXGFO3GakkmYDRhlzQ90/UBc6vIRO813iJo7V1DgVGn0VwlExeKWjuM1QOSYUFXFvSZf5KqPjuPPaeVhNQsIm8aGkXeXV44ZLV785XtcHOILUijod/O4+OWImVOXDr8qahpuEjVTRp5PNTdaN999bwsxeLIwa4S00FbxNTt685L4y0hpIgibvWKf3WMozutYK75p9+K5kK850lPG1Da3fzZw8M/8ROpN3iI6VNgG4tcPBREd9tQh3k1XVvqgcgo+Eb+uxRfXr/IVNKMeeVqI8fk/pxCxgahABAdG46g+GHQ3xjrH6XJscFUV9xwKHW35Kg+peZwYPOvbD4WmZCI3XHdZeNWN9/xZS+ystp9HYImcUduey7XAQWoqrsABiJZBUMZNVZnSADAG7IdBoUN1TYKxq6u04RhNycVFpqbcAzXDbLqXjh8VF5/4ccn382hOlj1wIHDiRk5UDOSUs6pyUFUVBBqSDSA3fXTGNbbXWU8f8JCai19PnSUPdfqWoJN8AkHTIt63DcZK7uTu+5GvEfniZn/jsklA1GwOMIMqKIiUqZpVpeo1mcAnPW01/OTqTZ4iOk08nGbzrI9XZ/kts7gwOUd2LB6w/otnVSLHFjRP/FhcggnZTwDNMO/cQoQE/pvp4vuRK6j8UJGqQsk4qqqKJHKcm2ymryh0UoP+HMN5yqenDk3J+cSdmkp63pSvORl+nU3mmJMRKYGwgcCJ679xoypVhdTZg8XN4lDoUOjwZCPBKGdKvofzr3KBt2oKm6tf1ZRypDnZy5Rp2vt1pKEXkRLVlUsqqqrQYRneoLDNB3MGb7IpdFKjiYfTfMqZkr3eHWIOSEW5U1NxNtao2ObkzT8o+X5N4wKlzQSRDkODwjjI9JRs8JeEiEADwLipKkRw4McpgOGYN9mGk4vuTVnkSO3pyDP1KJs8c+6CbdpVDVJGeJ+TJoxN7HVv2vn2iAGe8OnYv9MlbPD1osYv+3p4VIHBkFvWzNP+XG9eY4aBFr4bDNKEyFEatRk/UdTMnCXEjOtFTYi0k+3TGTxlCx6vNwd+nYu9b9t/F1fkIB0Gk/OlCP8egmaXmKUkclPpfP6Lrh3WI/qsKqzXwMybxP8sJlqPeGD6PIav8iabJEku3OKW0FlsPb2c5u/E5rt93QJtRhVAMOCRxPvEZGhcOJWKHOvi1rxmr++U8vUrbrQfbjAmYtZdHYmuISJHT1vHVGdWb341UcEXBwgaCJt7yjTyi3yRQtSl/ib7WUxJKEUyeHJIoMDLA0F07GhpH55Kr7HhpuGGhJd2touL1iNo9Abpn6dEg/J+MyXnM1J4MGdHrDazo1XrH1Nq4tb5fA5Jwyc9bX2UFBQ6SQqdDdbTw1n8bogdHRrbQTjcvHK37XPRXexUEjkAkaTfvNBaGs1o22sPbyyy2EGpfRLRu8jnhrhgixtEb5SmpOCfuXPFUBooQ8OwHQn68ORQtOf4u6UCSL5OV/oriNBBZRJMxRA5SaZ+5PmM139p0w8jR63w/kataFN+LHANwHUrB9xmCZ19lBR6kpfBI5nZ/VdZdyQ9fScz3xwhRhAFwetJQkRBmKgSO3iN5UQOgFjDhu6NluH9NScsdOTdpa5iR1ahJSFow6C6380I4WBtqHF9LsruBOtvFMJ61AjX60H0Z/DU5b8PAdJSSE+lZd79t65Don/wJfEXx94KFaEaBtVp634yFE1LAFxPdDifFQD7BIWOpuTFjFyX5S/H5rg6AYERFkSWvMMxVYuduPn0J/f0BWoA+OSLpVHgxvqpylNo5Y7nLo3D6VmlS72mYtUiBwLnih2d2oicSmIMAieoyEH0BsZd2fsmLZEjK9z+ovfnkUQO0nFXvHAoMZEjyUlVJTskU+jkW+jotDluua8xsZ8NkbPkoQOx/n1QHxFSVH5Rn3tTuihWizplyb0pbgwwFaNCB+IGXXMT6XeDKA4ETgKpkSyRpeGonkIzvbSqk3B8IETxiHqsYDge1f5cKsdjkSY+R9P3IJJjoTOusb1Jl9cylMY6lelrQMQjyY0QAuTJPdE8d/h3YSJCfg0EEbVKq4Hg6k2vaXnOT7fef5KRLSluZDM/TAlPqpmfHTWAyJmRnw7YSE2lHb1xHzs5GyzS8UDlGI6HwpL7IOdzi/lih0KHQqc4J9jqTa9mXi4JL0uSfWcQlQn7HvH/hxVIiJIN+OTuvRVZSYGIjq4pLNUGeD9xk3QzP6So0ooapAlSVVn0lsExw7HDsYx0PGA43vZcJqJz0dzrjD/uOt10EwqdRIGpLmrEQxXSmJwUUUQLfDlRBKBf6emyFBsIZn0sy6FisjuEjNwc0xI3I0ROzqaIZ/Z5FxfstCKEaiRgON62205XZSU6EdHJQVPQyTwbKXSSQjsTmA5RAKSvkkxvhH2PqEyLKjT8BFJaPhVEdQY0rAjBphAl3O8WN4jeYHOMGgGILHIaF1DkKEKOcYhqDMexsA3H9Tdmfj7nwKvDDskUOsVR0Yjq6GBkTbLTL95jGAFw5NjHkX4PRI5fVAdCJ607wBOD57Q88YNOdtdB3AxvrPCAUOQoIdbEcadsfNQj27VJHS5rNt6nxZlXmpKHPjpaquh3rI09jVLoSqAcGymOpDqPQgBMD2gMjiP8YEr2RnAgcvC9JLpBexn40BJ01lrqhgz3+0W85AgG3PFnJWp8hc76x1LZWO3GeD2vDj2fPycu9b5VdsO3R0pMmTrkTWm4UXtjNIQrUlWRvTjOqIrEukzHuF4Z3lOHqSsKHfWMa2zX9sTS5cOKuVH7I/pjdFpLpMq8BlwInbCVXJE2lmv0NctCyEofUWLzpRRhNwJMUkScPysu7dkpLmLEweDJ4P/GEUGXxEv2GIZzj3SIxsbrtTzeqKZCRC5qFRyM0qNW/MgSFHpOG8dnPI2blyLddBPzU1c8saogIx+m43fxS+u9zZlxtbbrck/zl1OvlooEmuyhT05CYH7T53fNGxq9MBjOD4bNX04Ln2tJxSWbD2l3Y6CiNw56+eD91cy8XtvzeXmzvq8tAIzoUOjwxMoKVGCl1XsmKWRUx0vSXh2kH3WuBqmdMU18f8pHeoob94UmYZFzcfMPQnX/hbiRGz8EDuZO4XugUmPMzgyio4jUQcRG7Y2DUve7xSK7O/PkKV8MnG7OgqR7RCUNS8wpdJKAEZ2APL1+gfHvIYuoTmPDVP0/xCk2d4sEojlJjXUYPDkkcgJu+OhWjE0f4gYbf7mJ4eUaY06/ZoKYdVdHpF5SUYDhGCInqpDF0FC8Vzybcj7feycv64RCZ8Q+x0MYcMOun2p891FEdfw6TycZ1Wmsn6b9uiQ9i0hnIXZxz87A4kZ2K5abfhBh7TXRI9qACCn+TgqeRCIblrBBRdWD4q1I/x7vG+8V79vdvNCE89nw6xRVGoUOT6oseey+eca/h7SjOibcAdsRE43FTqKv7fi7SsXNiJ9z/oLvGBCcaxieK2e33WAJHpWjX2AmRxQHFXNRwNgJpOSwBiaez/g8G+zVoZ2CQodkCfLfaY1PSAqkFNKK6ujuzxkhJuZ+W8/XhSqrJCt8pkxVKm68IKLjJ663r/vW8NeINDaveUk88EQ8E7M0HKN0PKrhGOk4DBKVfiM38OlNN8Sr12LuSIha7jQUOqphRCckEASmG5PLRXVUR6yMiOZIQQEPjIYzo5KONP1/9d9WLm78zjdvCsvvpgGenuY1eyN10o5rOIbXCFEcGKzzcD4jfWXodaqOuwyFjmoYJgx712gJgi2Gp7DKRXVUTzY3wc+QpqiIRMNNyd4+Ny8Qv57SkPjbWLr+QEm0BkLHWyEEQRS2QWdcwzFK4yFyyhmrTT2fczDRnFDokCwvIPAYmMwD2w75fl9las6kO2Bb6GhYfVUzJfk13L1pYeIpRqSn/CKJT6//VuSfCWEDgRPVcIz0FAQOSuPzeD4bWn3FLAOFjjrYryAeW+5rNPr14855V5nJ5ir6cEAImjZNOXE/TBRSeD043l3bbk/8eCE15Y0kyiqssMjZY1HHOMgeQNWiOO7XOd2wVJChPXWYZaDQIbqAC4jp/SrKlfaqGGbaGHK21aWeV/X4QCfVryYKKXqGcD7/846liUcqV2961TeFFTRlCpMxzMZRxzggigOzMUzH7rLx6sI93PmMxog6sMzsTsmEQodkDS7QpkUt3JTrlgyREnfDC/vvLz60KlRn3qSo0Ujo2MMyU44AdLXfLrq23ZGY4Cmfwqruj0LZOEZ14DkKqCpDFAfl4+GFe7h/s2rzq5FM1aoxscx8XGM701cUOspo4uGLRxKVSmlTLqrjLv+NJHRCRHRkNAejCDIHPXUSNgDrDo6dFDxJbJR+KSz8znK/C5EbRHCilo3LEQ6oKgsTxRkp3IOfz0gLI2rl1xk6i2uUgaZkpq8odIhOIDRssjEZd9i+rfqtu/uom1zYC+ulwz+3n6t16U2Lmlvu4IntiI+n1y0Qp15ZZQnfBUr9Hn4pLFQzeiOkaPonh61GwTvCIQph+0HJKGnY6rGkWH7LLJ7MhEKHxMP0JoLl5g75bTzVgDn0nvpw/2bYnzN4Ulzqezvz9bDLzDPsqSMHZi7t1cNIinMAgv7NHUvF0Rda7fMirujxS2F5I6QoG8cYhyhl4zKK4x3hkIZwl/4cfKZ2aSB28PoNS7EzokOhQ3S88zW45XrZMHvQ0RAQN0gtwD+Bu+8wYf5Lx4+O8OZc2rMj+wWxRE6aPXWwESPiAIMsog9yYGYSzfvigkgfzgm36InaewnnnLeRIATVPQ1jY5WNq4jijPh8h4jYwpdzwuXNefagJlEds65P9OhQ6CjjG3k5CGlMQa5GlOiHTmDT8TNPlquI8YobpBbsO2+IhBnBQ+VeX44d3Rk8mfl61DR/N9Gfj7JmNKpDBRC6EiPygCiOd/SADud2NdHzG0vwQPhEGSPiNwvrsXULI5WNlxvEqeJGJij7PdVWaM6pgymZ1VekqEInNyQ1ATkMuMCbnMKSAxbLiTh7Y7OEjK+4cQuEsJGQ3rerip9MhE79jUp72EDAuGdJyUZ11SqAjhz/2IjzB6ksnCdh/Ty+s7CsdR+1oi3U7680iDMOYdNWfqkqHUzJOB6mj64hFDqFBpuBDhcT0+dgwTzpd/fZMnOMODxlSOD4iZuRAiFExRI8OcdLZxNd1KH6SsQbCSHTUYgwyHSUnCUVJtpw5NhHxp1H0s8TtEz9Ekzoniie3aU6gNDEWlYaxBmXMGXluFnwpuLk50oH7rmTGSFCoWM05Qy1aROkH4jOrNr82mURYm1AF1e2iM/vmidmDwareqlpCB7VKtskEL9bgwaCo0KOhJA+G0QWZDoKEYY4G3BP30ljzyV3mbqf4IFghtn4wfM/Fxc3/3DkX46fKEbd96OKP19GcSoN4oz9HkL4zco1CdTFlLyIs68IhY7Z4GLywBOHtLi4mzhMD5sOojWbe7cMi5uLT/zYN+JSFtyBh0j3XDpcXsxcOvhi9ouCnjoV/EbYaKXPZpK4f9hnE3SsQCCh03vK+M+mW/DIiKcc4YDycft4975VIm4RUfPraZR0FEdSG3KEwv7D5RsZ6mBKhqfKkGvTV7mjUeiQchcT667Jbyp32jxmiDEZzdfuFkftDQdpKfhvYAINJW48G1Ngzp+1N7eyQkcXU7IrqgMBAyEDQQNhg402iM8mroDXZZyACsED4/I/Nf7ed4TDxc0/KOmOPWrdYyXiMukozvDrVTj2QRdT8qK515lwqrC8nEKHJ1Mlyk3lTvvOSdc5WFLcoMvsgLVd/FT8PPJgxBJREMKfEyQ1pYUp2RJvbgNxFmXfzx48mo8PpyVcMerjf+x5rqz4vbizfeT3EFWzxGZaUZyRwiy4gA0iRnUomoB/yuTqUEKhE5ZcOtNgBqQxuRTMB3KLm6jzgiqKgjD+HKcbciW0MCWPnyiuam5RWq4cFmyiOkQD4gC/1+crW6oKXPx/3qaRqMBaOH5lKlGcEUInjD/ncPXPE0rPdfAR0qtDiiR0cosOxmTcNW3JeA4WxAxEDcQNRE4S4uayyLkpVDfhS70B7m41MSW3aBDu/6EG/rNIIIrTdrft9wo6tPXSth+XiM3lK9I1+cObMz3EjUoQL5UuaUhWXxEKnRygizEZxr+052C5G/lB3CBNFWUQYmihUx+y2iropvfiTi2OY9bhfmyQOvjPwnBpZ7ttaq/kxfL9d8ePihN7Rkbz0o6Qhh3ieSJgxI09dQiFDlEGjMl+PS3SJu4U8CCgYgpzgSo18kt+Zwh+x32pL/jGZ2+SGpiSdWih7zcIU0uB0/f2UNWe128TRDDPmGV7cW7e+XHJe02zdUMYf06Y0nFck3S4LrFTMqHQyQkPPNGT+WtA+DuJjsmI0sgSXQgczAVKXdxIwo59CJmO0mGquQ4bA6IGqza/qu8HzjEbX1yzNLw4Rd+cR7aLUTs6xf+y4zHn83vIIz6mphYhDVOGHbYFwFMaRHWWU+gQCp18gJJOHRp1RZkBVA53xZQsB8+aUCZklK6H3AR1qL5CuD/uxG4VIIW1Wjexg1YBMk0VwVOFyrYrXjg03J4A69y17XbbvOuNfqQRIQ07xDNshEYHUzJuwNJOqxMKHZIQMHHqYEx+LKYxWZqKk6qYiiV05n47hPqMsEljI9VA7OgS7kdaVhexY6epVrZESlMNR3Gsh9fIDrHz/KaWkqgsNuikoxEtc4NHc/ZHMBfrYkpefgujOoRCJxdUGlaZ9iYZ5w4qLVNxJKGjYuyD37Fz5kXBs7H64LnsNwaNwv2Zi504aSpRGsXxA6kqbMbeqCxSwUmaw8OVlUcTLDqYknUw2RMKHaIIXFR0MABuua8xf4sbZuxDmSGefsLGPS8K/VN29Z7NvJcMNgWdWuhD7DS37U09Yhm0J44vFaI45W4QTlvvz/0ek2zIiWMcNEWJ14T0eBR0MCXjvbKnDsm70Okr0oHSwZiMC2jeTIBhxj54N8ZKwsZvXpQOd8HLb5ml1fpjo511V0cqqRCIVMxBC9MTx3uuVIvi+AFR4zX8qvS9uQmz8cddcx1MycuaZwlC8ix0ThfpQOliTN7izMGCiTizKimVQifE2IfTfb2hhI1fBCNrdAz3I7Kw5KFO+5FI1MsxG0PkRJqDFjKK48f0ayaMiOrgGCQR1QlTVr7/cDyvnA6mZKQH2VOH5FnoFA5djMlvrrjaLgvPhdAJ6M/Buv9Fz4xYE77xM3QQq7qG+xFhQHTnAYXneSyzsYgexfGCaOiR4x+P+B68Oqo36TD+nLiT5XGMdBHvhFDo5ARdjMm1d94Rqu+MviIn+NgHVamVZw9mvzHo3kIfKb6p39lum5UjR3gwYHPzDyKbjVVEcUo+N1MmlLwflT2qwox96FQUjXlKk7l8mvEGdysKHRJzE9DBmFyz5kfmC525we/Se/rUdDdGCjJrU7IpLfQRLUCEB4blMJEweKnsnjgRS/oxbVxFFMcLRIg3igKzsqpjESqao+h8RhPIrEd7YF116BFFKHSIQnQwJmM2VM0M84zJh8U08ai4SSwU3xXvNLQE/nf7FZpldYjKmTQYEeIQHZVllKes0EcUByXj1iOK2RjVd6O27Raj7vuRsiiOl9kzry4RBqqiOi2NwYe3qjR/7+o6mvk5ci8HfZIKjOYSmIc0JmfeAG68/lEBCBs8epxnSdgyXDR/U8Wk8WMyXxf4dB4wbKK49ITggSgIvBn4DOA4omTc9uGcjxYtQxRn1Iq2xM9pvFaINZhoJXgPEL8nYkb63D+zGmnO3UoD26ezmXsDyZ/QQR60qagHDhdGNswKLmz8NvrgwmRsqE3EBKY7QkGHDrdRgChAGnfinqfFDeKt6D8IUZz1Pwk1vT6+0B1bcqOCqE6cOWBhDbl5O5+xpmh9oYM5mugHU1eGIi/0FDaXU1GTxP3282brz5VEztCFnnNyFs29ztjXjvYGqPx7MIbIsb04OzpTFTny3POmL+N6dXg+Y/SFNuczL8wUOkQVuFhmbWw1RdiUbAwNUwt//mBzNS0iiDEiGAYLkRN1ICwqBpP24lRizsyr7RsVv9EQkYUOz2c7qqWJyf60IBQ6RB2rNr9GYRN2owlRhpt3TGqhP1ectAXO90Vv9AveijYxKoMojht57qmK6tSy6miE2CEkT0Knm4dvyJhsqs/CDzTiQ0M+lcKGd7/lMaH6SkZxDogXYzWpxHm1tO9/yLwcWoptVVEdns+XYfUVyZvQIQ529cx5M1NYUtig4zBGKmC0AkYsqBQ2JRsD/QwjNlyde+qoiOIMiIm2YMZ51dn7kWhe85Jd+ZRll/FJE4ZSht5u51GiOi0Ge61Uo0NPnU962ngTTqFDVN7prhNvic7BrXZ5rcnCBjOkMCQzDRjeHskyDQe1qoriIO2Jc8wrnGUzwqybb0LkeIsKwkZ1GNHR/3wmFDpRKayzHXe5PxU/t+5Uf2pXnWAjsHuIDJ7U9jV/X3w7M2FDkVOZpCfSh11zFVEcCGqca0h7ljvPIDJuXrk7k/ljZ85djuJA6LijOmHaRiB6wRYT6Z7PhEInNT7paSuUsx13uLjwvyN22He5d4vSbqQXN/9Q29f/nJiVibApuftl2qoEhPsbG5Jbl3vvbBDPP9JSdUNWHcUJOngV6aO0Izvu3+eN6oSZbE7h7nMeWeuX4bp08wjoBzsjaw5KaO+xBM5C8b69EVTiUu9b9pwf1TN68oSqMD82qjPnP1XyszDsMesqsOW3XG8b25MCG0/XNbeL5jV7fb0xOL8Rpax2jlcC6SlEC8NOlsfrwViVrvbbU1lrPzM0okrulBWEjjfSE1foqDxn9T+fZ+WqSIMUW+hAPTfl8cAgYrPMeiCMH4aLT/xYXNFwoxHjGdImbBkuNppyd9bYMGBqVXJRbr5ePL0uW3Fqp0ueGJuoQRdrf/SFVrHkoQPDogrCBgIHQicqiBQiRQXvV2Tx4QxbTWOD7uwpfa+yAkv6S2Sn30pNQcOMMQEQc0mKWfe5hAhe5ufz+LFZGM77eaXVD5qRNQLhepiLkZ7CxT+syLEZPGmMMTltwkRzhu7yD5W9K0QLfVXDGPdrcOeJTSGNnjr4PYicYO0gbnCuxxE5iOIgTRVH5FwWG+dSWety55S3r0619FXY6GQaIke+vywr2tw3EBlwgldaCh3V5MKQLM3FuOhLc3EcLkLoaGxMzuwuL0QZ7pHjH9vPqyqUIWOzVuFtwc/XIcy+rHlWar9rnaVLnhv/RuRUFaI4SFOhbBzl42pEWPLDVhG1KTe809tXB9GlSpt1mBEeafcO0uN8pimZ5EPonMnDQUAUx89cHJnzZ+0UFol+ByzvfiFCkGopx/OPLFRS9dJ5+P3s16d+avI9dZxz8+KapZF7P6Fib7ZYqSSKc/ncmJZ4/xWcS96ojZfSbsmzlJzPR46la7ber8H5jOOZQU+dbl5pKXRU089D6A9MyZf63uZCuDayMILEXRUD0VPOK4Gf+fym+H6E/ZoYJ5O8C8b5+PnKlsipVURx0H8JD5UVfNgMIViTBufQiSqz6fD37mgIxKdf1DDsGJN3Uq4q0yV9xagOodDJORc3/YCL4NAyN5z/5J1jH4/48wMVSpBV+HWwKegwmiARX8M5VxQnYkoV0RtEcRDNUf1+u7bdnngvGhzbatGcYUH04khRjYq4UuEezp9zxHM+p0FPb07P5wqwKzKFDoVOyqCK5NDOl7gQIrwR2e/Oe+n6AxX9OnF7d6RlFq2Eyp468N88J/aLmx9aGDmKMzB+2vD4BpVRnCGBc4dd7Za0yLHTn+s7Q50HbtHrNxaipTGc4MuiA3RPX/bnc8Y9dQiFjhL1rKXQwQV++vgQ/2D8BGW/Gz1EZMM03AEv3fOxLXh0uOBkRdiycmlE9gLxY88VK8N2a9OM43HRIaJTLoIQlrgVVTUNN9lTxq995ZD43x9ZbQuTOGtb6xh7cYxOvbLKFjiIxCUNRE653kGV2NU10rPnTsHgsxTmtWd1XpX7HKV/Pqdmsu+mpNCTPDQMRJxXi5G1qJZC7xt0ML5q5rzgF/X6m2xPTVRQYtsprrPD+t4KFFxg0fk1674WiKhkVYkR9o6uUmQFM5LQXdkv948NaPemhZE2Njt68aEeg1nj9NSJ3Rdn/EQxakWbqLlzxYjXI48hXhM2UKxVNb+LPR5hAnrNXJ2J0JYiJ0o05VmngaD04UCkydRX2DYAWZ1XOkQoh8/ndHrqFKpbP4VOumR+csn+N8OVU9bFuqY+uGfD7mQcskoKokaKm2ohfQgM3NWlcQdbDpTCZiF0wrTTd29QlYBwnD3zat8oEb732H3z7LL00CeyBuZNuWbYTJ8NOQMqbndjO4qz7jEhpkyr+Nrs87he70GWcUSOBOblLfcN3TDJUvNnPR2Ug3Bi8KwoOtWaLyri3ygp9CQPDQPfyOoXo/8N5vIgRO8uD69pviPcD7Iu7NX+DcQM5kWh4mSSuN9+DjM/avWmVzM9SMtiph6iAtGhutstNrHVm14rK4jwXqOYIHWaQh2mp4704uARSeQgivPIdjGq/bmKIscUkCqOK3IARI37HMMx2ZLA+ZwUSc5PC0vYm52I9FNSUOgkReoRHYgaTFeGyCnpXoyLtivsHvhA3PejkrENSEOh2gR+G0z+xgTwqFUnuKsLWvWRFE+vT3fMAe58o5SXBtlIsIlV8uvAAxK2hweGX2qzSZUpa/YS24vTuEBc8cKh3MxnQ+T0r1fuVmL+9TaSxDGJsmHXZiSMVHi9VJH04FoKHQqdpEmlO7J7ejjC8xi26bugEDlR7kohkNb9pMRMHGVIYTkQus3SmKxybEI1cOcb9XcF9UDgjntXhfROmLJlXIQbNUvHVFq/2FEc6zMyattuO5KTl7lsuJHA/DOVXhAVNydZVB1B5OvWw2b7um8l+vNZWq4vV5j+BsbUNiOi82CSAudvxb9a8qZLtFSZIF4zY5YYtWFb5N9VU3ud+MWUueKBw5+K34txyt/LhU8/tyM73/3mV7ITO9aGDrGVZEUGKmv+5tbZ0Y+5JU6CvkbcwS+4sVZ86Qulx+vKMaPtv/vHn/266u/b9w+3ZlqZVi4SgE37X44Ojvg+opi/EP+lrNivep5bNwNXWJ+TmunXiTyA6M1tf/dfxYu/fE/5z8b6Iw0a59zAeeh3HJPkZet89vtMZIlcw4Sq0E5/NnBwCyUFhU4iWCfXny2xcz8+zyp/rjQYI3rzLXHC+uGfV43IXLHtudh3p3NmfjFRIfDewB9tsVGbYZ4fPUCwOeC1qL6Qvf70Xba4UCHIIFAgDquJx9feHrA3I2woXnCxx1p3Hi5vxH7m4WbxtRumaPn5wloiffK7P/zJFvkbxT+Jx8Uvq38eykVxNm0Xo26927pDGWv6pccWD//Xrv8mWjcetNcniY153z8sVjLG4OvW+RXkfFZ1o6HiM5jUjVYS1x6Lt6y96BlKCgqdJKM6t1hPdaoEzqPiDVvgfE0MBrugI+1kiRxVd6gQAtU2xzig62+ciIeqDfT31uagStDhAgaRo0rAQbT85fQvBLpLx4aHC2e5SFkl8YpNIcsIWxDw+n739n8TO/7wf9uin1GcoeGcEDhJfUYhbg5uu13ZrCacz1+/4ZqKqVZVIkf3sQu49uDmRLE4fcYSOt2UFBQ6SQqda62nJlUCJ0xIHumqKxSKHPfmmJTYse/OrbvFr2cYRcCFF4JORfQKXhJcYP0iKnH4Su1VgUP+EDqV1hTvVUZGTNoUwNiB98TCnqfFpD9E64ty7pEO8R/u/F9zEcWBUFj60AHx7MF3E+vLAsMx5qepTmXieoKf+dqvTiTyuk05n3GdwI2e4nQehE6fIFpSk4c3Ma6xvdV6itRjHn4DpKhKqqeCRHE8jc2SAGHWqA3oKqFqGKUKntzTG7nHDhohJm22XPJQZ+DXh7EC5UzFOIaz7uoY9l2EKeHOAgj+Sb1viIs72yP9e1QNolLwoW1tZddkwKkG3O8MgUQEAxu9bPKmA7L6Ca8z6Z40aYiFMOdzUEw4n33Pvw/P2kUaCqrk5tOMTKGTtNBBzWVvKgKnwkUdpd+7xCxlVVLEPLA5//OOpWVL1JMSrkrfg7hgfza+H+4jNQK0RdgsbrL7PPmJP7x/CIdKU+FR/dYy9zq7v1AWogfH6inr9e3XZBK3ex3x2m5euZsfOE2wRE4NV4FCJw2xcyltgYOLuBQ3GMNACEBUolJpOdIfUTonpwE+F0jfIpUbVfAjiuP+PHiFDjZpDEgNEx2BBwujHLC25bpSx/48Y4J87yl7GCUiHrp1FEbUBP2ZJDcr6tdDYtNnCZ0GLoO+jM7Re+kWFXw6KgUOLuIQN0HGL5DiIZsJujclN0hN4P9JoSV9YFRHcSqtTZSIlj3R2zM7CUISXjZbCHkiRu6/GxYy5y74CgOUGweZnZU16NuE/lBSQNvn0RMUOjoIHS4BhU6aJ1tTUgIHd6oYuQCB4x2cSYjfpjTb8Zv4gQ0LJmwdBh8mEcVRKXLKMRSBOTkshIoAIk3Sw4PUXqXu3CQ1OONKc0bl9WSTc6h8xzSEQM6XQpdi3K1S5OgNTKynXlklzh9ak9Z8m7JgE6rUnOz5RxZm2s8IURxUGuIzElXkyBEl1USOHHKpszfJCAF98HJ5OHxgSaTwSKSbbEKhk97JpkLgQMxg9ELc+VIkfTAvSob25eTnLFmyvrOsjwKvc/emhZkYbVFRhXltUVNV+IwsFN+1PydB0rfwJFHkxAeRK/cYFxPKufMOq60odFLjjNh6Oq7AgaDBxRvRG9yp0n9j4Hlw7vJmOqCB56LapHPckW9fl+5AS6RyIXKSjuJIOnveV17OXGT2u9ZyUQZzrMgIKHIMwPiGgf/eeG3d39de9bj1ZUeUCzfEzFbxNTtys0PMYWrKcNAADOkgNPBr+8+vJ9KaPyx4Df9y9Hd21YwfaExo360nM4NnGERx9op94g4RbSYTPhtI4+JzciGEvS/NGUtFAB3FZWdzRAO9jShJquz7bODg/8Nl0Btjy8shcKynh61Ha5R/j143T1l3pvDgEJIG3vJgL0k0cpMgivOg9YgKop24GWCUUw+OvtA63KsJ1Xs0JWfGbZ/0tO3jMuiNcakrS+BMth4brC8/iCJyIGyQnkLonSKHpAkqsSrNGkIKS7W5VHpxooocCBtEcfCgyNEHpq+0oZtLoD/GRHQgcKwnTClvsx6Tw16sIWoQwWFqimRNpTERKkuwGcXJLxDEb+5YOvznG+7q0L4PUA7p/6Sn7Voug/4YEdGxRE6rGBrx8HAYkSOrp2AuxjNFDtGBSpVYKszJjOLkH5w/brN9C6M6WdDNJaDQUSFwmqwHUlQY2FkX9N/Bf4M7UVZPER2pVomFTQsT2aOAcnFUHkLsRAFRHHxu2FJBf9zpq5ZGHq8MeINLQKETR+DUW4/XrS9fDyNwoLAfFTdtpP+GmHBHvuShA2X/HkInzF06Kg4hcNAAEI0AQ4svRnGMAzO5JEiF6jLtvUB0cwkodKIIHBiNEb1BmqopxD+F633+6J4P5v+nnt0beFiJERtV70mxusJwz6DmZERxkKqK2j8K/XAYxTGPTs9UdUx5J6kBf04/l4FCJ6zIgUAJW0nVYT2utQTObdajm0qbmEalSizcoT9foXOyiigOvGuoQmQUx1SxfLn30qK5FKopwpJyCp1QAmex48MJYzSWAmeF9fBT1cydEmPAeIRy5mT0SunadnuJ2FERxUGKFx42Yi6dh98f/jqpiA6iis8/0mI/OFuLewyFTjiBI304L4vgPpxqAodqmxjJ0vUHKo6JeMyZ24XIjaooDqsQzccd0YEoTmJIrPSL4YEII7Hp5hJQ6FQSOPDhYGRDGB9OUIFj80lPGwZ8nubhJaaAHiirKvh1MLxx93314h2xI3IUB9WIjOLk77xxl5knEdWZNOFyNDENw3MSYk21yLH2GO4vFDplRU6rGPLh3J+EwPHAqA4xCphLy42AuNT3tvjOnv8UKYoDHhU32SKHUZz8MaLMPAGfzq6uo8PRxjRGTcyeebXuS/4znnVmMTqNX4I0lfWEKE5TCIGzMYK4cYMcaisPMTEJRHWONrRevnM+f1Zc3NkuLu3ZGennyZ5SeCb5BGXm995Zb389JwGRAMP8sxVGl6gGqdqBD8+V9a1pQDfPOrNINKITIU2FE2h+xAiOF0Z0iHHgzln210EU5/OVLZFFjoziUOTkXOik4NNJG3e6TDP6HWsEodAZqqYSwdNUUuDM95SJR8bJoVJ5E+O41PuW+GPbCnFxzVIhBsP7cZCegtl4syV0SDHEsTv6kYd+OpPGj9H1pfEGmkLHFjh1rmqqauXi/dbjNpUCxwNzqcSci7u4YFdToapqYm+06lUYjRHFQfk4KQ7vHPt4+OvZOSgB17iMnWXlBqLUo+M0/QsyXRwCBx6cjhTU9+M8zER3UEn1U/FzuwlgFBDFgReHAqeYwKeDyjxgckRHlrFPHj/WriZL0xsUgNOf9LQxolNUoeOYjWEkqK92oliPduux1RI5iZfnoUX3uMb2vgCvi5BMQBRnnXjLbgAYiSnTxKj1PxFvfjhRHK5Qnk7yzRFXRMfUpn6NDdPspoSSp9ctsJ81EjsUOUUWOmIogtNfRVBsFUNRnLT7DzxDoUN0BBPGnxP7I0dxau5cIUataBNi/ESxzDnDV1HsFFPoeCqUIBowSy0Jljdfb5ue4Q16ck90Xy4qC+fMHBJltVMmiHvuLL1Mo1nhdJe5uqdvyHh95tyFLKqyaIUostBx/DXdqLISQyXdSF/VOX+Nv1NRRRWVbh5mohuI4jxoPSJhCZtRm7aLmvobR3wbqYvp10wUS9Z3lu2yTPIBKqtwrAc+PGs3DZQiAFPMwZwZVycidCA88BgWVPXTxJKHOkP9DESckJ7yvp/JVZoRZixymLYymJqkfrAleppcIihTxjW2Iy/AqA7JHERx4MXBc6QPbOMCMWrdT2yxU+nuvnnNXoqdnGKPYnCleFZvftVO72y5b95wPx0Mik0iunfqlVUl3ZHHz9um5GcjCtXVfvuI70FElWuimTIdltBZwbPPTBIrL4fA0UHkODzDQ02yBlEcDOKMKnLOrvihGPXI9ooiR94xH32hlQMYc4qceybZ4vzZPQoC0Z4kSFI8IwLV3LbXFup4aCRyANNWFDraw5AjyQwIGwicyKkq4TT/67oy8EaDu25MPfemCIj5TPc0BJQRliPHLxuSZQpLNZt2vj3iz3E8OuXEjhyFopHIYdqKQkd/UH1lPbGbJUkdVFOhL07UKI4cxInmf/BihJk1hA0QKY5772TWNk94xYX0rhw5NvIcS6JDMlJkN6/cbQseRF+SmH3ljkzxRpmo4IqivNExtc3/wXq6hYecpHLXLc7aFVUrLalypfg80s9A87+7xSLxezFu+Hu4a8cGJqtVgrDgxlr733Qe/i0PTA547Vcn7MjelWNH214ciI0Ln35uPyBqrxwzVGOC452EaPjdH/5ki6ukBMmkCVfa56sUcBqw9rOBg/0888xlVIHeawcPN0kDRHGQqkITwEh3tM4IhwfFN3z//ofWxhZ2k0FF1ps7lpYYSYmZIKrTvOYlO7LiTme601eovDIVjYz0mG3VzTOOQscInNlXDEGSxEDzP6SpMMYBX0fhOTGr6ggHe/Dn+gOhf7Y0KaO6heQTlF4Pn4+Gilqk4NyCLWO4Z1DoGAed8yQRFor3xTtiR+Qozhkx1k5TYYwDvq66GRz/yC4rDi3GYFJuv52+nZwycrinmYIWQt4t2DKmnWcVhY5RfNLT1iGGxlAQogREbuDFwSNqFAfRm9lipTggrgv172AM3RWxPT5KkrevW8BUFtFesGVIt1PIQih0jKODh52oQEZx8BzpzlWMtX048OMEieL4Ab9O1E0Bvh2UoLPfTn5wG3iTKjEvEOy/RqFjLAxFklggcoPuxnGiOCgbh8BBZVUcEOZfuv5AZPMmRA7EznJn8jUhxIaeTgodc3FCkd089CQK8OCgoupucTTyz7Cb/4lltthRAfrrLHnoQOR/j/QVJkVv8XTcJTkQ5TlKTUKUy1lbSfQI8rDPKWAhFDrGwpAkCbdhiAt2NRWqqqJOG0fZuGz+pxp0lF0dc7YRDMooQU9hEym8+MA6nz+0xvZJqT4PRoiDmflIS+KcRORRCp0UzlNG/il0zIamZBIGOcIB/XGiIsvGVUVx/IhjTnbfNWMTYQl6ckBQSl8UfFJc6+pgndzRKXyd4HgTmJDZSZ9CJxd08PCTashBnFGjOGHLxuOCidVxZwTJEnT6dpLB66fSqJTa6HVUCCP+FDq5gaFJUhYVgzijlo2rEDsqynPh21GdWiGXI2+okEJn47DHSjZ+ROrr1CurKkY2Jo0fo/VaQFQjolXNS4RO0CM7QH8k9icz9PO0E/EnOaKmyG9+XGP7y9bTYp4G+QKmWulNeGBb+PJrRHHiCBxEbuDDiVtRFXcDUVU6jk0mieGNJBpILbqPKwTA1O9sH/4zBJAEQso7cVwnkQPBhme8BwwLPVFhtAn+v0WOqIPISSiis9ESOht4luWLUQV//4zq5AwYFeGBQA8RPLDZB608QXoKZuM4IkdV2XhcsAk0r9mrJLJjryd9JNrgFa+mVlZBtMjXHsRzg3Ma0TA8EkxbdfAMo9DJFc6wNprOcoR3Q8YFNEjlSdxBnADiJmnDcVixs3rTa0o2BQhIogdeD5YmXYRDc+TYx573kfl8qw52Qs4no7kEdlRnJ5chHwx8eFYIT0dY+3tlQBQHzf/iCByUjcNsXGkQZ2abibUJzrqrI3YaC9ExmWIg2QIP1mPn51mifqotFnRNTQU5N5c81Gmfl/jaWxqf0V5AckgNl8D26nxgPdVxJczH602BtwQeEz8wugEiJ2p3YwCjcVoVVSrXJQrNbXt12IxIFUzx6GgGSsrncxnyCSM6Q6Cc8GEug/lIUyM2dBgb/SIQcoRD1BlV9u9x5lShP44p6wLPDqqoEuw/QjQQtCQSG7kE+WUUl8Bmq2ADwVyBULifyIk7iBPAgwMvjikixy12kCqIWkFVKQVI9MDrRxsY5DELQJ/j1yQUOvnFmWnC/Gye73SdEQ5xBnECOacKvhxTQSoPUa8wJlb0fDnBTdM4Tgye4yJUh9d+Cp3CwKhOTpGDOOOMcICwQdl4EnOqsgAiB2JndYDmgrZpdH0nTyQDqJ0ygYsQjn42CMw/9Og4IKozrrEdyp5enRyBKE4cgQNMMRxHQfYlgacJ3h2U52OzhNcD5b4wH3u70hJ9mc6BrGGhN4dCp3AgqtNmPSbn+65voph+zURx5NhHud3AMMIBhmM8R8U0w3EcELWxIzus0DEab1UdPuOkLIzmFASmrlwUwauDQY2/eaHVHtqI9ut5rMCRgzjjiBxTDcek2Ey/ZmTqipG4ijCaQ6FTWHLt1cEcKAnSE4+5/mz8RV7BCAcgOxybbDgmxcQd0TG1Y3JKMJpDoVNc8h7V8fbZyEvfDZSLxx3hgFQVDMdIVxFiGt7xJ2fOf8pFKQ+jORQ6hSfTqA48NM8/0iK6tt2hPLWEMmE33rk5JqKibByG49lipZZjHAgJJHQ8o0/YxbosjOYUDJqRfci6AgvpJSlw5sy4Wkzt2a7sZ6NMGOkqmJFlRY2pQNggVRXHiwMQwcl62jghcfEakdkssCxruQQUOmQILSqwVKeWYE7EUEDTQYoqbhQHHpy7xSJtpo0TEgdv9Len9xQXpRTMtNrHZSgWTF2VwfHqZJLHxRA+eTfGgXyloC8OIjlxRA6qqWA4psgheRQ5uKFJqpM1br7gB4ozIDZD6M0pIJxeXgVONtcHOcbhbnE08s8oUm8cUhwwrHVZ8/XDf4b3DnPNkuDNHUuHRQ5+h0E+P04oLyiM6FSH+VwNkKXjcUQOojeoqqLIIbm6ARg/doTIsYXO4fcT+V3eSM6iudeZtFQreLZQ6BAfnHxuN1ciO2A2jtsAUPbGYaqKZA2EApp1nnplld3AMy6LfCoz9ycUZUEBg7sJYU+fMZVdHda1vJ9nXzGhGTkYyOs2cRnSBxEcjHKIClJVmFOF8nFCdGDLmnnDM6lQYYlZY3FYv+LGEX9GKinJjsgYBgtPkJyFJkG0R9OSdvgtGZkvMIzoBMC6E+jGHQFXQu1dLe5ozx9aY/sL/IAfJ47IkWMcKHJIXkFEyDvIM6m0lQQmZ7SlcIsa9P6aNH6MrsvU7hSXEAodUoW1wuDREPfeWW8LCl1mW+H1yNJ5+AtqXRdr2R8nztRxjnEguvLAtkN24048ljx0INbP8kZzEMnZn4E5GH25NK3CQnPADTzrig1TVwHJuolg3Ls+OeMKogKh56zn4Jz2hNbln+NOHWeqiugOPnvNa15S8rn2RnOQBuMgzxHQgEwodEKKnQ2W2PmeMKzc3HsxnDQh+/lW6A80efxY+07wyT299sUZ4iZOfxykqtAAkFEckncQDd3iM5D3qQw7nWsY0dnn2A4IhQ6JcIfwukkveJd1lydTRbibPHIs+6nG3g7NcU3HKBlHJIeQIoAxLt6u6fDNnMho7AP8OdOvmWC/Jk0iSjQgk2HYMDAC4xrbX7aeFpv2unWtioDpOKofhw0ASdGAzw5Df703DrPu6shEZCCyhBsp+Tqa1+zNPDVusZHeHCKhGTkaK4SBxmTdRA5SVIjiRBU5bABIvAJA9Ww43UB6yK9K8YEnDmUicvB6pMixP9PW+j+/aWHFfwMDNaotUXWZUHFEH0UOccOITkTGNbbfbz09nqf3hIvUnJlfFAMfnk08BB538jjEDSI5iOgQAtCED+cwDLlPZZjGSfLz2bXt9hIvTJLjHiSIBjfWTx0WN9LnJ79XDkR25IgI+TVEzvDNV98pJcZsD/PpzSEUOurEDrw6TXm5G8adorwjXr351diNzMoBcYPJ4xjrEJYkU1VYg3vvbLC/hkHaoBk+RAxVIT3tinbg+D178GgujmM5kYPhv3+9cndm0Zw5M68esebyNSGNVg5EcuR1JgGRttUSOfTmkBFcwSWIzpja5jesp/vz8F46NtwyopdNS+N1iUxOnytOir1in/iS+FPofyurqn6RQNEb7lj3/eRWew3w+O43v2LfbQ7kLCqgE9goOzY02/OS3hv4o/jdH/4U6+ehU+8up7y69pqJ4ms3TLGPoyzD/r318+P+Dp1EDt7nbX/3XzM7R7GWWHN8XhAJlq+p7T+/bh/Pcrz29oD4Su0XxDvHPrYLEi58+rmql9RvPZZ+NnDwz/x0ETeM6MRkXGP7BmFgb51Kd1mS8fO2Kf0dcSqrkk5VwTfgbb4GoZeE2CNDINUkWx8kkX6BeF1+y/UjvDtIn0AM4feZkNoqJ3JAc9tebXx3WGN8fmBEzrDqiikr4gvNyDFxTG99pr8Pb5oK0QyVrBNvRRY5EDgoHU/Sj+N3V8xoTrK4+zsl0dsJIgARA6RRkIqFuIFgQJXQbyyR9eaOpfbmrGlHXzsSBTHoF8mBKNSpuGDgw3PW6/o0S5HDnjmkLExdKWBMbTNu+1eb/B5e+9WJoS9qasTh3lNKQ8pRK6vQ+A9VVWl0OUYIHhEAmb6D0EMlC0lwc7SEJFKk2Bz/fvs/VUx3xAHnMY7vi798z+41c8z+PTVDBlvr8Te3zrZFBQTF5Aljs96w7ehI+9/9R7ua6coxo0tEDqImqm9E4oI01vLmWXa0LANQATufKStSDqauFJGXFJZKUFkF0zF8OWGBuEk6iuOHvHvWoA8ISfr8HD9WLLJERcvc6yzBM3VE6hYirMcS/HaDTc+U7qTOO4xnwevxdjKX2LOx1ndqO+Kha9sdSVRQBeG2T3ra9vGMJhQ66Yid3FRhqRA5UcvHkarCUE5C0gTRnZa5X7ZFj186C6IHKRr7eRAtGM5FasWA34NOwvgd+HrOjKsr9v/B7/rhE4e0rx5DBOrJ9EdQsMqKUOikLHTqrCfkaCYXeR2izqxC9AapKlRXEZKpULeEBwRPY/20ssLHT5BA/PhRO2VC2UhNOSCo0A/o2WzSQZGEYsq+oX7r0YCByzxjCYVOumInd40Ew4A0FdJVYUXOYTHNLh1nA0Ci80aO6AtEz+yZVydiYpZN9fAwLX2awZwrVlkRCp0MxY6Rs7DiErV8/FFxk9hsPQgxDdkl2K9rcLkojjvygwG7+DN8QPhaV/+NhnCWFaHQyVjoIHX1gShQCgtVVRjOGQZEbxDFQTSHEEICgllWNPGRwLCPTgI4OePbivJ+EcUJK3Lgw5krllHkEELCUKhrK1ED++gkxGcDB/vH1DYjYtaU1/cIH85O0SXuEO+F+nfocnyHda2iH4cQEpKl1o3kW1wGEgamrhImryXnUcrHkxzISQjJPSwlJ5EYzSVIHIRZc+XXwdRxVFaFETnocgw/DkvHCSER6KPIIVGhRydh8ubXgbg5LHaFEjnocgw/DkUOISQC9OWQWNCjkwJ58eugR85esS9UjxyUjq8V37T+BYOHaYF+Jtv+j/9ozx7C/CjMISLEYOjLIbGgRydFTO6vE7ZHDvw4mFWV1EBOTKBGy3nd5/9kwfZ1C+y5SfZxsNZl6ne2c1GIqbBfDokNU1fpssJ69Jn2osOKHKSokpw6jqZsEDkAjdrk12SI6ddcblJXaYYSIZqzjyKHUOgYhuPXgdgxZjYLBE4YkQNxk/a8KkZzRvLknl7X131cEGIifc61kpDYMHWVAeMa25G+etkEkYNoTlDSnDqO1NWcmV8UZ85dEKs2v0qxQ0h+wI0g5lhRpRMKHcPFjrbDP2E2Rvk4zMdBSNqPkwW1UybaPhfMITJlejQhOeE2S+Ts4zIQVbAUJiOsD/JWS+x81fqyVTeRE6YRIFJUEDl5Kh2Hr+XNHUtH+FsodghJhbUUOUQ19OhkK3a0MidD3IQROVn4cdIAKTG3yPGbQE0IUU4HbgC5DIRCJ3/M10HshBU56I+DTsd5nFfV03tSHDl+eR1Qwk4ISZRu58aPEOXQo6MB4xrbUR+NmViZjImQIidII8CizKtCRAeRnYEPz4oTg2d5khKSHLjRm+9UpRJCoUOxo5YwPXI4r4oQohiImwZL5PRzKUhScASEJnw2cHBwTG3z70SKnZPDiByIm2+JJbbYIYQQRSIHkZz/l0tBkoQRHc0Y19jeaj3tTPr3rBNviQdFsPExSFOhsooQQhTSwF45JA0Y0dGMzwYO9iU9ABRRnO+L3kD/LwQOjMeEEKKQFZbIOchlIGnAiI6mjGtsR1SnNQmRE6TbMUzH8OMcFtN4MAghqkVOB5eBUOgQpWInTCPAPDYBJIRQ5BAKHZJTsRNG5CCCk9f+OISQTOlgrxxCoUPKiR0Yauqj/Nvp4qw9tyqIyKHpmBBCkUPyBmddmQG6J78eVuyEaQQIgZP3JoCEEIocUjw4AsIAnI6hoUZFBBU5SFFhXlWeRM7y5ut50hBCkUMIhU5exc5C8X4gkQOzMURO3iqrOISTEIocQih0cip2UDoOT05QkZPHyir35HFCTDx/u7bdIc4fWmM/G3o+U+QQCh2iXuwEHemANNVcsSy3lVUYxkmIqSxq/LJorJ9qf41n/JkihxAKnaKKnQ75vUfFG4FEDiaP57myqpZpK5IzTp+/YNLLpcgh2sGqK7PFzopxje0QOK3Vuh0jegORk/fKqunXTLTEzgSeIMRYnu16V8ye8UU7Mnnk2Eeis+e3prz0rdZ1aS2PINEN9tExnH9vvLZqQ0FZWZX3TsdzrM1hy5p5drgfm8OmnW+LI8c/4klCSPKw4zGh0CHKBc5k6+llUWX4J8QNOh0PiPyndE69smqEcXNg8KyYdRevvYRQ5BAKHWKiyKnaQDCv4xwQuZk0Yeg9SdMmvDnLfPrnIKJz5vynoqf35IjvI9pDCIkF0udrKXKI7tCjk1ORk9dxDojYSJEDELVB35xyhk2ksHr6Tg2JnmMQPRd4EhGiRuTMt0ROH5eC6A4jOmaJHIibndVEzoCYuHG2WNlmfTm5SOuDniMywgN2db0rVm1+lScOIWrptx63UeQQCh2ShMh5vYp4sUPJo3s+6BjX2B7k/88dGP/w9LoFYrUlcFC9QghRCsTNfKfqkxAKHZK6yJlviZzhuyxL7ARKc+UNdJQdP28bTxxC1LJPDBmPKXKIUbBhoP4iZ3EAkQNx0+AWOcDVWHAfV5IQEgP0yLmNIoeYyBVcAq1FTqv1tNt6XFnhf+u2Hs2WyBn0+8vPBg7+2Xr8lzG1zRBKNxVl7aQBmRASG0RxtnAZiKkwoqO3yNlZ5X/rsAQO0lVV77KcjqVszU4ICQquKw0sHycUOiQJkXN/AJGz0RI4oYSLc8FqcC5guYUl5ITEps8ROaysIsZDM7J+IqfqSAeLFaisivo78m5SRvPAE4NneTIREg1cW9bSj0ModEgWIgcXntsskdOt4vdZgudx6+l+rjwhxAECZyuXgVDokKxEznxvZZUCsYPfCcEzmUeBkMLCTseEQockJnCCpJH6HJGTSCjZaS5YteMyISSXdIuhTsdMVREKHZKJyLEvQkmJHJfYwWtBZKeVR4aQwrDREjgbuAyEQodkJXI6wlZWKRA8rYKpLELyju33s0RON5eC5B2Wl2cjcuoDiJyNaYsc4CpBZ66ekHyCTunXUuSQosCITnYip1LEJFb5uCrGNbZvsJ4e5lEjJBcgirORVVWEQodkKXKUlo8rEjtNYsioXMcjSIixIEK7glVVhEKHZC1ylJePKxI7NCoTYi40HBMKHZK4yIFA2Fnlbmt+0pVVCgTPYud90KhMiP4wikMIhQ5FTgSxM9l5P4t5dAnRFkZxCKHQ0ULkdGRRWaVI8DQJencI0Q1GcQih0ElN5OBu6uE8ihyX2JnsvEfOyyIkWxARbmcUhxAKnbRETrW5VVqUjysUPE1iyKzMERKEpE+3GIri9HMpCKHQochJVvAgsoMID83KhCQPhA2mje/jUhBCoaODyNG2fFyx2KlzxE4rzwhCEmOj9djKQZyEUOikJXAQwXjZejQVWeR4BA/WguksQtTSLZimIoRCJwORU2lulVHl4wkInlbBIaGExAXChmkqQih0KHI0FTtYJ+nfIYQEh/OpCKHQyVTo9FYQOcaXjycgeOoE/TuEBIU+HEIodDIVOYhS/JEiJ5LggThEOquJq0FI6fVDDEVx+rkUhFDoZCl0sEm/7vNXuS0fT0DwYA0fpuAhxAb+m7UUOIRQ6OgsdChyKHgICUu3GIrgdHMpCKHQ0UnotIrLc6wKVz5OwUMIBQ4hJjCaSxCZOooctTgX/G4KHpJzOqzHMxQ4hKQDIzoRcYZ23mo9brNETj9XRD0UPCSHAocmY0IodIwROugL01H0HjkpCZ46wbJ0Yib2VHFcKyhwCKHQISSI4IHYaRPstEz0pt8lcHgzRAiFDiGhRY8UPJylRXSiGwKHoxoIodAhRJXgabKevieY1iLZgYgNhA39N4RQ6BCSmOCZLC6nteq4IiQFUGmJ9NQ+pqcIodAhJE3R0ySGojyLBb08RC0QNB1iKD3Vz+UghEKHkCwFz2RH7ED0NHFFSAyQmnqG3htCKHQI0VX01LlEDw3MJKi4+ZlgaooQCh1CKHpIToDv5hlH3PRzOQih0CGEooeYjozcdFPcEEKhQ0jeRU+TGBrtsZgrkltkOfgbgmkpQih0CCmw8IHY+YYjfhjtMRukpKTfhgN4CaHQIYR4RE+dI3ik8KnjqmhNv7gctelm1IYQCh1CCIWPySBK0209/k3Qa0MIodAhJBHhU+8In3rBvj1JctoRNm844qaPERtCCIUOIemLn3pH9HyV4keJqOlzRE0/l4UQQqFDiJ7ip04MpbkgempdX1PQDAkZiJgTgpEaQgiFDiG5FECI/GB0xVedZ/nnPNDvepxwfU1BQwih0CGEQsgWQlL8ABkREp7vp02362tEZc54vt/PdBMhhEKHEKJSGFUTPpUiRf3OwxdLtHRzhQkhhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCSCH5/wUYABONbH+/AR5WAAAAAElFTkSuQmCC"
profile = ProfileReport(
df,
title="NASA Meteorites",
html={"style": {"logo": logo_string}},
correlations={"cramers": {"calculate": False}},
explorative=True,
)
profile.to_file(Path("./meteorites_report.html"))
def test_repr(data):
report = ProfileReport(data)
assert repr(report) == ""
"""Display a profile report.
Parameters
----------
profile_report: pandas_profiling.ProfileReport
The profile report instance to display.
key: str or None
An optional key that uniquely identifies this component. If this is
None, and the component's arguments are changed, the component will
be re-mounted in the Streamlit frontend and lose its current state.
"""
with st.spinner("Generating profile report..."):
_pandas_profiling(html=profile_report.to_html(), key=key)
if not _RELEASE:
import numpy as np
import pandas as pd
from pandas_profiling import ProfileReport
df = pd.DataFrame(
np.random.rand(100, 5),
columns=['a', 'b', 'c', 'd', 'e']
)
pr = ProfileReport(df, explorative=True)
st.title("Pandas Profiling in Streamlit")
st.write(df)
st_profile_report(pr)
import pandas as pd
import numpy as np
from pandas_profiling import ProfileReport
PATH_TO_FILE = "https://raw.githubusercontent.com/owid/covid-19-data/master/public/data/owid-covid-data.csv"
FINAL_FILE_NAME = "owiddataset"
FINAL_HTML_PATH = "../webpages/" + FINAL_FILE_NAME + ".html"
df = pd.read_csv(PATH_TO_FILE, error_bad_lines=False)
profile = ProfileReport(df, title=FINAL_FILE_NAME, explorative=True)
profile.to_file("../webpages/owiddataset.html")
Incidents_service = pd.read_excel(
"C:\\Users\\dell\\Desktop\\P31_Project\\Extras\\DataSet\\Incident_services.xlsx"
)
pd.options.display.max_columns = None #Helps to see all column names in the Dataset
Incidents_service.head(10)
Incidents_service.dtypes
Incidents_service.shape
Incidents_service.isnull().sum()
Incidents_service.describe()
#import the packages
from pandas_profiling import ProfileReport
# Run the profile report
profile = ProfileReport(Incidents_service,
title='Pandas Profiling Report',
explorative=True)
# Save the report as html file
profile.to_file(output_file="pandas_profiling_P31.html")
invalid = lambda x: sum(x == "?") / len(x)
Incidents_service.apply(invalid)
#"problem_id" and "change request" has highest number of missing values which are represented by '?'
#Hence, we can eliminate those columns.
# Column 'ID_status' has some mis-interpreted values with entry- '-100'
Incidents_service.ID_status.value_counts()
#Hence, we can drop those entries as it won't affect our model
Incidents_service = Incidents_service[Incidents_service.ID_status != -100]
def show_analysis(request):
df = pd.read_excel('production/data.xls')
df.to_csv('data.csv', encoding='latin-1')
prof = ProfileReport(df, minimal=True)
prof.to_file(output_file='Templates/analysis_output.html')
return render(request, "analysis_output.html")
def run(st, data):
expander = st.beta_expander("Menu", expanded=True)
with expander:
ana_choice = st.radio(
"Analysis",
["Data", "Visualization", "Statistics", "Data Profiling"])
filters = st.checkbox('Add Filters')
if filters:
st.info("Select column and values from below")
filtered_cols = st.multiselect("Select columns to filter",
data.columns.tolist())
filtered_sets = []
if len(filtered_cols) > 0:
iterations = len(filtered_cols) // 3
difference = len(filtered_cols) % 3
jack = 0
while jack < iterations:
cols_filtered = []
try:
cols_filtered = cols_filtered + st.beta_columns(3)
except:
pass
counter = 0
for i in range(jack * 3, 3 * jack + 3):
filtered_sets.append(
cols_filtered[counter].multiselect(
filtered_cols[i],
data[filtered_cols[i]].unique().tolist()))
counter += 1
jack += 1
if difference == 0:
pass
else:
cols_filtered = []
cols_filtered = cols_filtered + st.beta_columns(difference)
counter = 0
for i in range(iterations * 3,
iterations * 3 + difference):
filtered_sets.append(
cols_filtered[counter].multiselect(
filtered_cols[i],
data[filtered_cols[i]].unique().tolist()))
counter += 1
#Now filtering the data
tracker = 0
for filter_value in filtered_sets:
if len(filter_value) > 0:
data = data[data[filtered_cols[tracker]].isin(
filter_value)]
tracker += 1
if ana_choice == 'Data':
data_options = st.selectbox(
"", ["View Records", "Data Correlation", "Pivot"])
if data_options == "View Records":
c1, c2 = st.beta_columns(2)
top_bottom_options = c1.radio("Records", ["Top", "Bottom"])
num_rec = c2.number_input("No. of Records:",
min_value=0,
max_value=100,
step=1,
value=10)
if top_bottom_options == 'Top':
st.dataframe(data.head(num_rec))
else:
st.dataframe(data.tail(num_rec))
elif data_options == "Data Correlation":
select_columns = st.multiselect("Select Columns",
data.columns.tolist())
corr_view = st.radio("Correlation View", ["Table", "Chart"])
if corr_view == 'Table':
if len(select_columns) == 0:
st.dataframe(data.corr())
else:
st.dataframe(data[select_columns].corr())
else:
if len(select_columns) == 0:
st.write(sns.heatmap(data.corr(), annot=True))
st.pyplot()
else:
st.write(
sns.heatmap(data[select_columns].corr(),
annot=True))
st.pyplot()
elif data_options == 'Pivot':
dimensions = st.multiselect("Select X axis columns",
data.columns.tolist())
measures = st.multiselect("Select Y axis columns",
data.columns.tolist())
numeric_cols = st.multiselect("Aggregation columns",
data.columns.tolist())
aggregation_operations = st.selectbox(
"Aggregation Operation",
['sum', 'average', 'median', 'count'])
button = st.button("Execute!!!")
if button:
if len(numeric_cols) > 0:
if aggregation_operations == 'sum':
operation = np.sum
elif aggregation_operations == 'average':
operation = np.mean
elif aggregation_operations == 'median':
operation = np.median
elif aggregation_operations == 'count':
operation = np.count_nonzero
pivot_table = pd.pivot_table(data,
values=numeric_cols,
index=measures,
columns=dimensions,
aggfunc=operation)
st.dataframe(pivot_table)
elif ana_choice == "Visualization":
chart_options = st.selectbox(
'Charts', ['Bar', 'Line', 'Heatmap', 'Distplot', 'Customized'])
if chart_options == 'Bar':
x_col = st.selectbox('X', data.columns.tolist())
y_col = st.selectbox('Y', data.columns.tolist())
hue_color = st.checkbox("Add color column")
direction = st.radio('chart direction',
['vertical', 'horizontal'])
if hue_color:
hue_col = st.selectbox('hue', data.columns.tolist())
button = st.button("Execute!!!")
if button:
if direction == 'vertical':
chart_direction = 'v'
else:
chart_direction = 'h'
if hue_color:
if hue_col:
st.write(
sns.barplot(x=x_col,
y=y_col,
hue=hue_col,
data=data,
orient=chart_direction))
st.pyplot()
else:
st.write(
sns.barplot(x=x_col,
y=y_col,
data=data,
orient=chart_direction))
st.pyplot()
else:
st.write(
sns.barplot(x=x_col,
y=y_col,
data=data,
orient=chart_direction))
st.pyplot()
elif chart_options == 'Line':
x_col = st.selectbox('X', data.columns.tolist())
y_col = st.selectbox('Y', data.columns.tolist())
hue_color = st.checkbox("Add color column")
if hue_color:
hue_col = st.selectbox('hue', data.columns.tolist())
button = st.button("Execute!!!")
if button:
if hue_color:
if hue_col:
st.write(
sns.lineplot(x=x_col,
y=y_col,
hue=hue_col,
data=data))
st.pyplot()
else:
st.write(sns.lineplot(x=x_col, y=y_col, data=data))
st.pyplot()
else:
st.write(sns.lineplot(x=x_col, y=y_col, data=data))
st.pyplot()
elif chart_options == 'Heatmap':
select_columns = st.multiselect("Select Columns",
data.columns.tolist())
button = st.button("Execute!!!")
if button:
if len(select_columns) == 0:
st.write(sns.heatmap(data, annot=True))
st.pyplot()
else:
st.write(sns.heatmap(data[select_columns], annot=True))
st.pyplot()
elif chart_options == 'Distplot':
x_col = st.selectbox('X', data.columns.tolist())
col = st.selectbox('column', data.columns.tolist())
row = st.selectbox('row', data.columns.tolist())
button = st.button("Execute!!!")
if button:
st.write(
sns.displot(
data,
x=x_col,
col=col,
row=row,
binwidth=3,
height=3,
facet_kws=dict(margin_titles=True),
))
st.pyplot()
elif chart_options == 'Customized':
code_area = st.text_area(
"""Enter your chart script, Return result to value.
e.g.
a = 3
b = 4
value = a + b!!!, Don't enter data parameter !!!""")
button = st.button("Execute!!!")
if button:
loc = {}
exec(code_area, {'data': data}, loc)
return_workaround = loc['value']
st.write(return_workaround)
st.pyplot()
elif ana_choice == 'Statistics':
test_selection = st.selectbox('Category', [
'Value Count', 'Normality Test', 'Correlation Test',
'Stationary Test', 'Parametric Test', 'Non Parametric Test'
])
statistics = stats.Statistics(data)
if test_selection == 'Value Count':
select_columns = st.selectbox("Select Columns",
data.columns.tolist())
mode = st.radio('Value Counts', ['Table', 'Chart'])
if mode == 'Table':
value_counts = statistics.__get__stats__(select_columns)
st.dataframe(value_counts)
else:
value_counts = statistics.__get__stats__(select_columns)
st.write(value_counts[:20].plot(kind='barh'))
st.pyplot()
elif test_selection == 'Normality Test':
st.write("""
Tests whether a data sample has a Gaussian distribution. \n
H0: the sample has a Gaussian distribution. \n
H1: the sample does not have a Gaussian distribution"""
)
select_test = st.selectbox(
'Tests', ['ShapiroWilk', 'DAgostino', 'AndersonDarling'])
col = st.selectbox('Select Column', data.columns.tolist())
text_option = st.checkbox('Text')
chart_option = st.checkbox('Chart')
if text_option:
t, p = statistics.normality_tests(data[col],
test_type=select_test)
st.write('#### ' + t + " (" + str(p) + ")")
if chart_option:
st.write(sns.kdeplot(x=col, data=data))
st.pyplot()
elif ana_choice == 'Data Profiling':
st.markdown("""
##### The Data Profiling is done automatically using Pandas Profiling tool.\n \n \n \n
""")
limited_records = st.checkbox("Execute on Limited Records!!!")
select_columns = st.multiselect("Select Columns",
data.columns.tolist())
if len(select_columns) == 0:
cols = data.columns.tolist()
else:
cols = select_columns
if limited_records:
num_rec = st.number_input("No. of Records:",
min_value=0,
max_value=1000000,
step=1,
value=100)
else:
num_rec = len(data)
execute_profiling = st.button('Execute!!!')
if execute_profiling:
st.title(f"Pandas Profiling on {num_rec} records")
report = ProfileReport(data[cols].loc[:num_rec, :],
explorative=True)
st.write(data)
st_profile_report(report)
"occupation",
"relationship",
"race",
"sex",
"capital-gain",
"capital-loss",
"hours-per-week",
"native-country",
],
)
# Prepare missing values
df = df.replace("\\?", np.nan, regex=True)
# Initialize the report
profile = ProfileReport(df, title="Census Dataset", explorative=True)
# show column definition
definitions = json.load(open(f"census_column_definition.json"))
profile.set_variable(
"dataset",
{
"description":
'Predict whether income exceeds $50K/yr based on census data. Also known as "Census Income" dataset. Extraction was done by Barry Becker from the 1994 Census database. A set of reasonably clean records was extracted using the following conditions: ((AAGE>16) && (AGI>100) && (AFNLWGT>1)&& (HRSWK>0)). Prediction task is to determine whether a person makes over 50K a year.',
"copyright_year": "1996",
"author": "Ronny Kohavi and Barry Becker",
"creator": "Barry Becker",
"url": "https://archive.ics.uci.edu/ml/datasets/adult",
},
)
profile.set_variable("variables.descriptions", definitions)
def main():
"""Diabetes Prediction App"""
html_temp = """
<div style="background-color:navy;padding:10px;border-radius:10px">
<h1 style="color:white;text-align:center;">Echidna AI</h1>
<h5 style="color:white;text-align:center;">Diabetes Prediction WEB APP</h5>
</div>
"""
components.html(html_temp)
image = Image.open('C:/Users/Adila/Documents/hep_app/LOGO.png')
st.image(image, use_column_width=True)
menu = ["Home", "Login", "SignUp", "Book An Appointment", "Profile Report", "About", "Privacy Policy"]
submenu = ["Plot", "Prediction",]
choice = st.sidebar.selectbox("Menu", menu)
if choice == "Home":
st.subheader("---------------WELCOME TO THE DIABETES PREDICTION APP-----------------")
html_temp2 = """
<div style="background-color:navy;padding:3px;border-radius:10px">
<h1 style="color:white;text-align:center;">How to Login?</h1>
<h5 style="color:white;text-align:center;">press the arrow on the top left corner and choose the LOGIN from menu to get started</h5>
</div>
"""
components.html(html_temp2)
html_temp3 = """
<div style="background-color:navy;padding:3px;border-radius:10px">
<h1 style="color:white;text-align:center;">How to Sign Up?</h1>
<h5 style="color:white;text-align:center;">press the arrow on the top left corner and choose the SIGN UP from menu to get started</h5>
</div>
"""
components.html(html_temp3)
st.title("Brief explanation on Diabetes Mellitus")
st.subheader("------Diabetes mellitus (DM), commonly known as diabetes, is a group of metabolic disorders characterized by a high blood sugar level over a prolonged period. Symptoms often include frequent urination, increased thirst, and increased appetite. If left untreated, diabetes can cause many complications. Acute complications can include diabetic ketoacidosis, hyperosmolar hyperglycemic state, or death. Serious long-term complications include cardiovascular disease, stroke, chronic kidney disease, foot ulcers, damage to the nerves, damage to the eyes and cognitive impairment.")
st.subheader("------Diabetes is due to either the pancreas not producing enough insulin, or the cells of the body not responding properly to the insulin produced. There are three main types of diabetes mellitus:")
st.subheader("------Type 1 diabetes results from the pancreas's failure to produce enough insulin due to loss of beta cells. This form was previously referred to as insulin-dependent diabetes mellitus (IDDM) or juvenile diabetes . The loss of beta cells is caused by an autoimmune response. The cause of this autoimmune response is unknown.")
st.subheader("------Type 2 diabetes begins with insulin resistance, a condition in which cells fail to respond to insulin properly. As the disease progresses, a lack of insulin may also develop. This form was previously referred to as non-insulin-dependent diabetes mellitus (NIDDM) or adult-onset diabetes . The most common cause is a combination of excessive body weight and insufficient exercise.")
st.subheader("------Gestational diabetes is the third main form and occurs when pregnant women without a previous history of diabetes develop high blood sugar levels.")
st.subheader("------Type 1 diabetes must be managed with insulin injections. Prevention and treatment of type 2 diabetes involves maintaining a healthy diet, regular physical exercise, a normal body weight, and avoiding use of tobacco. Type 2 diabetes may be treated with medications such as insulin sensitizers with or without insulin. Control of blood pressure and maintaining proper foot and eye care are important for people with the disease. Insulin and some oral medications can cause low blood sugar. Weight loss surgery in those with obesity is sometimes an effective measure in those with type 2 diabetes. Gestational diabetes usually resolves after the birth of the baby.")
st.subheader("------As of 2019, an estimated 463 million people had diabetes worldwide (8.8% of the adult population), with type 2 diabetes making up about 90% of the cases. Rates are similar in women and men. Trends suggest that rates will continue to rise. Diabetes at least doubles a person's risk of early death. In 2019, diabetes resulted in approximately 4.2 million deaths. It is the 7th leading cause of death globally. The global economic cost of diabetes related health expenditure in 2017 was estimated at US$727 billion. In the United States, diabetes cost nearly US$327 billion in 2017. Average medical expenditures among people with diabetes are about 2.3 times higher.")
elif choice == "Login":
username = st.sidebar.text_input("Username")
password = st.sidebar.text_input("Password",type='password')
if st.sidebar.checkbox("Login"):
create_usertable()
hashed_pswd = generate_hashes(password)
result = login_user(username,verify_hashes(password, hashed_pswd))
#if password == "12345":
if result:
st.success("Welcome {}".format(username))
activity = st.selectbox("Activity", submenu)
if activity == "Plot":
st.subheader("Data Vis Plot")
df = pd.read_csv("data/clean_hepatitis_dataset.csv")
st.dataframe(df)
df['class'].value_counts().plot(kind='bar')
st.pyplot()
#Freq Dist Plot
freq_df = pd.read_csv("data/freq_df_hepatitis_dataset.csv")
st.bar_chart(freq_df['count'])
if st.checkbox("Area Chart"):
all_columns = df.columns.to_list()
feat_choices = st.multiselect("Choose a Feature",all_columns)
new_df = df[feat_choices]
st.area_chart(new_df)
elif activity == "Prediction":
st.subheader("Predictive Analytics")
age = st.number_input("Age",7,80)
sex = st.radio("Sex",tuple(gender_dict.keys()))
steroid = st.radio("Do You Take Steroids?",tuple(feature_dict.keys()))
antivirals = st.radio("Do You Take Antivirals?",tuple(feature_dict.keys()))
fatigue = st.radio("Do You Have Fatigue",tuple(feature_dict.keys()))
spiders = st.radio("Presence of Spider Naeve",tuple(feature_dict.keys()))
ascites = st.selectbox("Ascities",tuple(feature_dict.keys()))
varices = st.selectbox("Presence of Varices",tuple(feature_dict.keys()))
bilirubin = st.number_input("bilirubin Content",0.0,8.0)
alk_phosphate = st.number_input("Alkaline Phosphate Content",0.0,296.0)
sgot = st.number_input("Sgot",0.0,648.0)
albumin = st.number_input("Albumin",0.0,6.4)
protime = st.number_input("Prothrombin Time",0.0,100.0)
histology = st.selectbox("Histology",tuple(feature_dict.keys()))
feature_list = [age,get_value(sex,gender_dict),get_fvalue(steroid),get_fvalue(antivirals),get_fvalue(fatigue),get_fvalue(spiders),get_fvalue(ascites),get_fvalue(varices),bilirubin,alk_phosphate,sgot,albumin,int(protime),get_fvalue(histology)]
st.write(feature_list)
pretty_result = {"age":age,"sex":sex,"steroid":steroid,"antivirals":antivirals,"fatigue":fatigue,"spiders":spiders,"ascites":ascites,"varices":varices,"bilirubin":bilirubin,"alk_phosphate":alk_phosphate,"sgot":sgot,"albumin":albumin,"protime":protime,"histolog":histology}
st.json(pretty_result)
single_sample = np.array(feature_list).reshape(1,-1)
#ML
model_choice = st.selectbox("Select Model", ["KNN", "DecisionTree", "LR"])
if st.button("Predict"):
if model_choice == "KNN":
loaded_model = load_model("models/knn_hepB_model.pkl")
prediction = loaded_model.predict(single_sample)
pred_prob = loaded_model.predict_proba(single_sample)
elif model_choice == "DecisionTree":
loaded_model = load_model("models/decision_tree_clf_hepB_model.pkl")
prediction = loaded_model.predict(single_sample)
pred_prob = loaded_model.predict_proba(single_sample)
else:
loaded_model = load_model("models/logistic_regression_hepB_model.pkl")
prediction = loaded_model.predict(single_sample)
pred_prob = loaded_model.predict_proba(single_sample)
#st.write(prediction)
#prediction_label = {"You have a risk to have diabetes":1, "You don't have a risk to have diabetes":2}
#final_result = get_key(prediction,prediction_label)
#st.write(Ffinal_result)
if prediction == 1:
st.warning("Patient has a risk to have Diabetes")
pred_probability_score = {"Dibetes":pred_prob[0][0]*100,"No Diabetes":pred_prob[0][1]*100}
st.subheader("Prediction Probability Score using Neural network with {}".format(model_choice))
st.json(pred_probability_score)
st.subheader("Prescriptive Analytics")
st.markdown(prescriptive_message_temp,unsafe_allow_html=True)
else:
st.success("Patient don't have a risk of having Diabetes")
pred_probability_score = {"Has a risk":pred_prob[0][0]*100,"No Risk":pred_prob[0][1]*100}
st.subheader("Prediction Probability Score using Neural network with {}".format(model_choice))
st.json(pred_probability_score)
if st.checkbox("Interpret"):
if model_choice == "KNN":
loaded_model = load_model("models/knn_hepB_model.pkl")
elif model_choice == "DecisionTree":
loaded_model = load_model("models/decision_tree_clf_hepB_model.pkl")
else:
loaded_model = load_model("models/logistic_regression_hepB_model.pkl")
# loaded_model = load_model("models/logistic_regression_model.pkl")
# 1 Die and 2 Live
df = pd.read_csv("data/clean_hepatitis_dataset.csv")
x = df[['age', 'sex', 'steroid', 'antivirals','fatigue','spiders', 'ascites','varices', 'bilirubin', 'alk_phosphate', 'sgot', 'albumin', 'protime','histology']]
feature_names = ['age', 'sex', 'steroid', 'antivirals','fatigue','spiders', 'ascites','varices', 'bilirubin', 'alk_phosphate', 'sgot', 'albumin', 'protime','histology']
class_names = ['Die(1)','Live(2)']
explainer = lime.lime_tabular.LimeTabularExplainer(x.values,feature_names=feature_names, class_names=class_names,discretize_continuous=True)
# The Explainer Instance
exp = explainer.explain_instance(np.array(feature_list), loaded_model.predict_proba,num_features=13, top_labels=13)
exp.show_in_notebook(show_table=True, show_all=True)
# exp.save_to_file('lime_oi.html')
st.write(exp.as_list())
new_exp = exp.as_list()
label_limits = [i[0] for i in new_exp]
# st.write(label_limits)
label_scores = [i[1] for i in new_exp]
plt.barh(label_limits,label_scores)
st.pyplot()
plt.figure(figsize=(20,10))
fig = exp.as_pyplot_figure()
st.pyplot()
else:
st.warning("Incorrect Username or Password")
elif choice == "SignUp":
new_username = st.text_input("User name")
new_password = st.text_input("Password", type='password')
confirm_password = st.text_input("Confirm Password",type='password')
if new_password == confirm_password:
st.success("Password Confirmed")
else:
st.warning("Passwords not the same")
if st.button("Submit"):
create_usertable()
hashed_new_password = generate_hashes(new_password)
add_userdata(new_username,hashed_new_password)
st.success("You have created a new account")
st.info("Login to get started")
elif choice == "Profile Report":
st.title("What is Profile Report?")
st.subheader("------This technology can be used to upload datasets that you may have as analyst or if you are a doctor who wants to get a clear idea about percentage of patients who has this or that problem. And then the technology itself will analyze it.")
st.title("How to start to analyze the data?")
st.subheader("------To analyze the data you just simply need to upload a CSV file")
st.title("What kind of files this technology accepts?")
st.subheader("------Basically a CSV files")
st.title("How is it analyzing the data?")
st.subheader("------Mainly, technology itself uses a neural networks to analyze the data, and then it will represent the data as a charts")
data_file = st.file_uploader("UPLOAD CSV",type=['csv'])
st.set_option('deprecation.showfileUploaderEncoding', False)
if data_file is not None:
df = pd.read_csv(data_file)
st.dataframe(df.head())
profile = ProfileReport(df)
st_profile_report(profile)
elif choice == "Book An Appointment":
st.title("Book An Appointments")
st.title("Integration with Nilai medical center website")
st.subheader("------Developer integrated this WebApp with existed website to make sure that patients can book an appointment to a real medical")
components.iframe('https://nmc.encoremed.io/',width=700,height=2000)
elif choice == "About":
st.title("About App")
st.title("F.A.Q.")
st.title("What is Echidna AI?")
st.subheader("------Basically, its an a WEB APP that can help people to predict Diabetes")
st.title("What kind of functions do Echidna Have?")
st.subheader("------The main purpose of the Echidna AI is to provide a solution for people to predict diabetes and to help analysts to analyze the data in a better way. And the data itself can be stored inside this WEB APP because it has a neural network that can store data inside nodes")
st.title("Is it Open source Alghorithm?")
st.subheader("------The Echidna AI® algorithm")
st.subheader("------This web app was released as open source software under the GNU Affero General Public Licence, version 3. This ensures that academics and others interested in the core of the algorithms at least start with a working implementation. The terms of the licence ensure that implementations are transparent and open, and are, in turn, open for others to use and/or modify under the same licence.")
st.title("Is Echidna AI can be recommended for clinical use?")
st.subheader("------It can be recommended for clinical use, software developers can use this professionally supported software development kits.")
st.title("Would Echidna AI be supported in future?")
st.subheader("------Echidna AI®-2020 will be released to licencees of our Echidna AI® software development kit in the new year, for deployment from August. Which means that it will be suported")
st.title("Do Echidna AI patented or is it has a copyright?")
st.subheader("Yes, Echidna AI has a copyright, but it is an open source software that can be modified")
st.subheader("------Copyright ©Echidna 2020. ALL RIGHTS RESERVED.")
st.subheader("------Materials on this web site are protected by copyright law. Access to the materials on this web site for the sole purpose of personal educational and research use only. Where appropriate a single print out of a reasonable proportion of these materials may be made for personal education, research and private study. Materials should not be further copied, photocopied or reproduced, or distributed in electronic form. Any unauthorised use or distribution for commercial purposes is expressly forbidden. Any other unauthorised use or distribution of the materials may constitute an infringement of ClinRisk's copyright and may lead to legal action.")
st.subheader("------For avoidance of doubt, any use of this site as a web service to obtain a Echidna AI® for any purpose is expressly forbidden. Similarly, use of this website for developing or testing software of any sort is forbidden unless permission has been explicitly granted.")
st.subheader("------BMI predictor algorithm © 2020 Echidna Inc.")
st.subheader("------WebApp and risk engine built by Adilan Akhramovich WebApp design ©Echidna 2020.")
#components.iframe('https://quickdraw.withgoogle.com',height=2000)
components.html(footer_html,height=500)
elif choice == "Privacy Policy":
st.title("Privacy Policy of Echidna Inc.")
st.subheader("------At ECHIDNA AI, one of our main priorities is the privacy of our visitors. This Privacy Policy document contains types of information that is collected and recorded by ECHIDNA AI and how we use it.")
st.subheader("------If you have additional questions or require more information about our Privacy Policy, do not hesitate to contact us.")
st.subheader("------This Privacy Policy applies only to our online activities and is valid for visitors to our webapp with regards to the information that they shared and/or collect in ECHIDNA AI. This policy is not applicable to any information collected offline or via channels other than this webapp.")
st.title("Consent")
st.subheader("------By using our webapp, you hereby consent to our Privacy Policy and agree to its terms.")
st.title("Information we collect")
st.subheader("------The personal information that you are asked to provide, and the reasons why you are asked to provide it, will be made clear to you at the point we ask you to provide your personal information.")
st.subheader("------If you contact us directly, we may receive additional information about you such as your name, email address, phone number, the contents of the message and/or attachments you may send us, and any other information you may choose to provide.")
st.title("How we use your information?")
st.subheader("We use the information we collect in various ways, including to:")
st.subheader("------Provide, operate, and maintain our webapp")
st.subheader("------Improve, personalize, and expand our webapp")
st.subheader("------Understand and analyze how you use our webapp")
st.subheader("------Develop new products, services, features, and functionality")
st.subheader("------Communicate with you, either directly or through one of our partners, including for customer service, to provide you with updates and other information relating to the webapp, and for marketing and promotional purposes")
st.subheader("------Send you emails")
st.subheader("------Find and prevent fraud")
st.title("Log Files")
st.subheader("------ECHIDNA AI follows a standard procedure of using log files. These files log visitors when they visit websites. All hosting companies do this and a part of hosting services' analytics. The information collected by log files include internet protocol (IP) addresses, browser type, Internet Service Provider (ISP), date and time stamp, referring/exit pages, and possibly the number of clicks. These are not linked to any information that is personally identifiable. The purpose of the information is for analyzing trends, administering the site, tracking users' movement on the website, and gathering demographic information.")
st.title("Advertising Partners Privacy Policies")
st.subheader("------You may consult this list to find the Privacy Policy for each of the advertising partners of ECHIDNA AI.")
st.subheader("------Third-party ad servers or ad networks uses technologies like cookies, JavaScript, or Web Beacons that are used in their respective advertisements and links that appear on ECHIDNA AI, which are sent directly to users' browser. They automatically receive your IP address when this occurs. These technologies are used to measure the effectiveness of their advertising campaigns and/or to personalize the advertising content that you see on websites that you visit.")
st.subheader("------Note that ECHIDNA AI has no access to or control over these cookies that are used by third-party advertisers.")
st.title("Third Party Privacy Policies")
st.subheader("------ECHIDNA AI's Privacy Policy does not apply to other advertisers or websites. Thus, we are advising you to consult the respective Privacy Policies of these third-party ad servers for more detailed information. It may include their practices and instructions about how to opt-out of certain options.")
st.subheader("------You can choose to disable cookies through your individual browser options. To know more detailed information about cookie management with specific web browsers, it can be found at the browsers' respective websites.")
st.title("MCPA Privacy Rights (Do Not Sell My Personal Information)")
st.subheader("Under the MCPA, among other rights, consumers have the right to:")
st.subheader("------Request that a business that collects a consumer's personal data disclose the categories and specific pieces of personal data that a business has collected about consumers.")
st.subheader("------Request that a business delete any personal data about the consumer that a business has collected.")
st.subheader("------Request that a business that sells a consumer's personal data, not sell the consumer's personal data.")
st.subheader("------If you make a request, we have one month to respond to you. If you would like to exercise any of these rights, please contact us.")
st.title("GDPR Data Protection Rights")
st.subheader("We would like to make sure you are fully aware of all of your data protection rights. Every user is entitled to the following:")
st.subheader("------The right to access – You have the right to request copies of your personal data. We may charge you a small fee for this service.")
st.subheader("------The right to rectification – You have the right to request that we correct any information you believe is inaccurate. You also have the right to request that we complete the information you believe is incomplete.")
st.subheader("------The right to erasure – You have the right to request that we erase your personal data, under certain conditions.")
st.subheader("------The right to restrict processing – You have the right to request that we restrict the processing of your personal data, under certain conditions.")
st.subheader("------The right to object to processing – You have the right to object to our processing of your personal data, under certain conditions.")
st.subheader("------The right to data portability – You have the right to request that we transfer the data that we have collected to another organization, or directly to you, under certain conditions.")
st.subheader("------If you make a request, we have one month to respond to you. If you would like to exercise any of these rights, please contact us.")
st.title("Children's Information")
st.subheader("------Another part of our priority is adding protection for children while using the internet. We encourage parents and guardians to observe, participate in, and/or monitor and guide their online activity.")
st.subheader("------ECHIDNA AI does not knowingly collect any Personal Identifiable Information from children under the age of 13. If you think that your child provided this kind of information on our website, we strongly encourage you to contact us immediately and we will do our best efforts to promptly remove such information from our records.")
#Explore data list(df) df.shape df.info() df.describe().transpose() df.head(n=20) df.tail() pd.isna(df) df.isnull().sum() df.corr() # In[ ]: # Generate profile report using pandas_profiling ProfileReport(df) # In[3]: #Creating target variabled Purchase_Ch df['Purchase_CH'] = np.where(df['Purchase'] == "CH", 1, 0) # In[4]: #Convert Store7 to a binary variable df['Store7'] = np.where(df['Store7'] == "Yes", 1, 0) # In[5]: #Check distribution for StoreID
# Using VS Code
# In the terminal >>
#pip install pandas
#pip install pandas-profiling
import pandas as pd
from pandas_profiling import ProfileReport
df = pd.read_csv('RCOM.csv')
print(df)
# if DLL load failed error occurs>> inside terminal>>
#pip uninstall pandas
#pip install pandas==1.0.1
# >>>>>>>>>>>>>>>> Generate a Report >>>>>>>>>>>>>>>>>>>>>>>>>>>>
profile = ProfileReport(df)
# if the dataset is very large & you want to minimise the report, instead of the above line, use---->>
#profile = ProfileReport(df, minimal = True)
profile.to_file(output_file='RCOM_Report.html')
#Now the .html file will be created wait for some time and then view it with live server
def _get_profile_report(self, title, minimal):
return ProfileReport(self.dataframe, minimal=minimal, title=title)
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 28 08:49:08 2020
@author: PC-4
"""
# %% import
from pandas_profiling import ProfileReport
import numpy as np
import pandas as pd
# from warnings import filterwarnings
# filterwarnings("ignore")
# %% data
df = pd.read_csv("train.csv", index_col="datetime")
df.rename(columns={"count": "demand"}, inplace=True)
# %% Overall
profile = ProfileReport(df, minimal=False, progress_bar=False, title="Overall")
profile.to_file("Overall.html")
consolF = consolF[consolF.columns[(consolF.isna().sum()==0)]]
consolF.isna().sum()
consolF
consolF.to_csv('/content/gdrive/MyDrive/shp/DatosFinales.csv')
data_train= consolF[consolF.tipo_data == "train"].drop(["tipo_data"], 1)
data_test= consolF[consolF.tipo_data == "test"].drop(["tipo_data"], 1)
data_train
data_test.columns
"""# Estadísticas descriptivas"""
ProfileReport(consolF, title="Datos", minimal=True)
"""Una manera rápida de la visualización de los datos que el reto nos indica es a través de este scatter plot donde para nuestra variable de interés $y$ observamos la nube de puntos para algunas variables que nos parecieron relevantes."""
pd.plotting.scatter_matrix(data_test[['area', 'estrato', 'banos', 'piso', 'valoradministracion', 'y',
'latitud', 'longitud']], figsize=(16,16))
mapHouses = folium.Map(location=[4.624335, -74.063644], zoom_start=10)
dfSamplesTrain = data_test
locations = dfSamplesTrain[['latitud', 'longitud']]
housinfo = ['area: '+str(area)+', banos: '+str(bano)+', estrato: '+str(estrato)+', valor venta: '+str(valorventa) for area,bano,estrato,valorventa in zip(dfSamplesTrain['area'],dfSamplesTrain['banos'],dfSamplesTrain['estrato'],dfSamplesTrain['valorventa'])]
locationlist = locations.values.tolist()
for point in range(len(locationlist)):
folium.Marker(locationlist[point],popup=housinfo[point]).add_to(mapHouses)
mapHouses
import numpy as np
import pandas as pd
from pandas_profiling import ProfileReport
df = pd.read_csv("algar-dataset-treino.csv")
prof = ProfileReport(df)
prof.to_file(output_file='output.html')
from matplotlib import pyplot as plt
from pandas_profiling import ProfileReport
from sklearn.metrics import mean_squared_error
from sklearn.metrics import average_precision_score
#Leitura dos dados a partir do arquivo Excel.
data_set = pd.read_excel("teste_smarkio_lbs.xls")
print(data_set)
#Utilização de comandos da biblioteca do xlrd para manipulação dos dados dentro da planilha.
book = xlrd.open_workbook_xls("teste_smarkio_lbs.xls")
page1 = book.sheet_by_index(0)
#Relatório com a análise descritiva unidimensional exportado para arquivo .html.
profile = ProfileReport(data_set, title = "Análise Exploratória dos Dados")
profile.to_notebook_iframe((output_file="analise_exploratoria_dos_dados.html"))
#Tratamento dos dados para colocá-los em listas.
limit = len(page1.col_values(colx=0)) - 1
print(limit)
i = 1
list_true_class = page1.col_values(start_rowx=1, colx=3)
list_pred_class = page1.col_values(start_rowx=1, colx=0)
print(list_true_class)
while i < limit:
if list_true_class[i] == "":
list_true_class[(i)] = list_pred_class[i]
i = i + 1
