mmanager 2.3.3

Modelmanager API With Causal Dicovery and Inference and Model Features

Welcome to Modelmanager-api!

This is a api model for interacting with modelmanager.

Note:

• Example files are are in example_script directory.
• Example assets are in assets directory.
• It contains scripts for different actions(Add, Update, Delete).
• Check logs from file mmanager_log.log

---

Example Codes

Add Applications

from mmanager.mmanager import Applications
secret_key = 'Secret-Key'
url = 'URL'
application_data = {
    "name":""
}
Applications(secret_key,url).post_application(data=application_data)

Add Classification/Regression

from mmanager.mmanager import Usecase
secret_key = 'Secret-Key'
url = 'URL'
data = {
        "name": "Determination Of Origin Of Wine Using Chemical Analysis",
        "description": "Wine is one of the most popular alcoholic drinks which has been used for thousands of years. Wine is produced by fermenting grapes.", #(Optional)
        "image": '/path/image.jpg', #(Optional)
	}
Usecase(secret_key, url).post_usecase(data)

Other optional data

Key word	Example
author	John Doe
usecase_type	Classification (Options: Classification, Regression, Forecasting)
computing_type	Classical (Options: Classical, Qantum, Hybrid)
source	Forina, M. et al, PARVUS -An Extendible Package for Data Exploration, Classification and Correlation.,Institute of Pharmaceutical and Food Analysis and Technologies, Via Brigata Salerno,16147 Genoa, Italy.
contributor	S. Aeberhard, D. Coomans and O. de Vel, Comparison of Classifiers in High Dimensional Settings, Tech. Rep. no. 92-02, (1992), Dept. of Computer Science and Dept. of Mathematics and Statistics, James Cook, University of North Queensland.
is_private	Set True to keep the usecase private. Default False.
trustability	Set True to list in trustability. Default False.
explainability	Set True to list in explainability. Default False.
hide_model	Set True to hide model related to this usecase. Default False.
notification_emails	List of emails that will be notified. Eg: [e-mail], [e-mail]

---

Forecasting Usecase

usecase_info = {
    "name": "",
    "usecase_type": "Forecasting",
    "author": "",
    "description": "",
    "source": "",
    "contributor": "",
    "image": "",
    "performance_data_selection": "",
    "applications": ""
}

forecasting_fields = {
    "performance_data_selection": "",#eg:{'from':'2020-09-09', 'to':'2020-11-01'}
    "notification_emails": ["[e-mail]"],
    "forecasting_template": "two_conditions"
}


forecasting_feature_tabs = {
    "result_tab":True,
    "series_tab":True,
    "condition_tab":True,
    "performance_tab":True,
    "ab_testing_tab":True,
    "release_tab":True
}
Usecase(secret_key,url).post_usecase(usecase_info, forecasting_fields, forecasting_feature_tabs)

Update Usecase

from mmanager.mmanager import Usecase
secret_key = 'Secret-Key'
url = 'URL'
project_id = Project_id #use model_id number to update
data = {
		"author": "AuthorName",
		"description": "UsecaseDescription",
		"source": "UsecasSource",
		"contributor": "UsecaseContributor",
		"image": 'image.jpg' , #path to image file
		"banner": 'banner.jpg' , #path to banner file
	}
Usecase(secret_key, url).patch_usecase(data, project_id)

---

Get All Usecases Uploaded By Authenticated User

from mmanager.mmanager import Usecase
secret_key = 'Secret-Key'
url = 'URL'
usecases = Usecase(secret_key,url).get_usecases()
print(usecases)

---

Get Usecase Detail

from mmanager.mmanager import Usecase
secret_key = 'Secret-Key'
url = 'URL' 
usecase_id = "Usecase-Id"

# GET USECASE DETAIL
usecase_detail = Usecase(secret_key,url).get_detail(usecase_id)
print(usecase_detail)

# GET ALL USECASE UPLOATED BY AUTHENTICATED USER
_usecases = Usecase(secret_key,url).get_usecases()
print(_usecases)

# GET ALL MODEL ID REGISTERED UNDER USECASE
model_list = Usecase(secret_key,url).get_models(usecase_id)
print(model_list)

---

Delete Project

from mmanager.mmanager import Usecase
secret_key = 'Secret-Key'
url = 'URL'
project_id = Project_id #use project_id number to delete
Usecase(secret_key,url).delete_usecase(project_id)

---

Add Related Database

from mmanager.mmanager import ExternalDatabase
secret_key = 'Secret-Key'
url = 'URL'
# db_type: Postgres, MySQL
related_db_data ={
    "db_type":"Postgres",
    "db_name":"db_name",
    "db_user":"username",
    "db_password":"db_pass",
    "db_host":"localhost",
    "db_port":"5432"
}
ExternalDatabase(secret_key,url).post_related_db(data=related_db_data)

Link External Database

from mmanager.mmanager import ExternalDatabase
secret_key = 'Secret-Key'
url = 'URL'
# link_type: Client, System
external_db_data = {
    "link_type":"System",
    "usecase":"usecase_id",
    "external_db":"related_db_id",
    "train_table":"",
    "test_table":"",
    "pred_table":"",
    "actuals_table":""
}
ExternalDatabase(secret_key,url).link_externaldb(data=external_db_data)

Add Tables

from mmanager.mmanager import TableInfo
secret_key = 'Secret-Key'
url = 'URL'
table_data = {
    "table_type":"" #eg:"actual",
    "table_name": "" #eg:"daily_act2",
    "db_link": #eg:11
    }

TableInfo(secret_key,url).post_table_info(data=table_data)

Add Fields

from mmanager.mmanager import FieldInfo
secret_key = 'Secret-Key'
url = 'URL'
field_data = {
    "table_id": "" #eg:9,
    "display_name": "" #eg:actual2,
    "field_type": "",
    "field_name":""
    }
FieldInfo(secret_key,url).post_field_info(data=field_data)

Load Database Cache

from mmanager.mmanager import Usecase
secret_key = 'Secret-Key'
url = 'URL'
Usecase(secret_key,url).load_cache(usecase_id=7)

---

Add Model

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
path = 'assets' #path to csv file

model_data = {
    "project": "1", #Project ID or Usecase ID
    "transformerType": "Classification", #Options: Classification, Regression, Forcasting
    "datasetinsertionType": "Manual" #Options: AzureML, External DB, Manual
    "training_dataset": "/path/train.csv"
    "test_dataset": "/path/test.csv"
    "pred_dataset": "/path/pred.csv"
    "actual_dataset": "/path/truth.csv"
    "model_file_path": "/path/model.h5"
    "target_column": "Class"
}
Model(secret_key, url).post_model(model_data)

Other optional data

Key word	Example
note
model_area
model_dependencies
model_usage
model_audjustment
model_developer
model_approver
model_maintenance
documentation_code
production	Production (Options: production, observation, retired)
model_input_data	"/path/input.csv" (Path to input data.)
computing_type	Classical (Options: Classical, Qantum, Hybrid)
binarize_scoring_flag	Set True to label binarize. Default False.
algorithmType	Xgboost (Options: Xgboost, GBM)
modelFramework	driverless_ai (Options: driverless_ai, tensorflow, keras, scikit, statmodlib, other)

---

Create Config File For Azure ML Credentials

• Get Credentials from your existing Azure ML account.
• Create a config file in following format
• Give credential file path in credPath field to enable using AML integration service.

{
    "subscription_id": "<subscription-id>",
    "resource_group": "<resource_group>",
    "workspace_name": "<workspace_name>",
    "tenant-id": "<tenant-id>",
    "datastore_name": "<datastore_name>"
}

Add Model, Fetch Datasets And Model From Azure ML

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_data = {
    "project": "<project-id>", #Project ID or Usecase ID
    "transformerType": "model-type", #Options: Classification, Regression, Forcasting 
    "target_column": "target-column-name", #Target Column
    }

ml_options = {
    "credPath": "config.json", #Path to Azure ML credential files.
    "datasetinsertionType": "AzureML", #Option: AzureML, Manual
    "fetchOption": ["Model"], #To fetch model, add ["Model", "Dataset"] to fetch both model and datasets.
    "modelName": "model-name", #Fetch model file registered with model name.
    "dataPath": "dataset-name", #Get datasets registered with dataset name.
    }
Model(secret_key, url).post_model(model_data, ml_options)

Add Model, Upload Datasets And Model Manually And Register To Azure ML

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
path = 'assets' #path to csv file
model_data = {
    "project": "1", #Project ID or Usecase ID
    "transformerType": "Classification", #Options: Classification, Regression, Forcasting
    "datasetinsertionType": "Manual" #Options: AzureML, External DB, Manual
    "training_dataset": "/path/train.csv"
    "test_dataset": "/path/test.csv"
    "pred_dataset": "/path/pred.csv"
    "actual_dataset": "/path/truth.csv"
    "model_file_path": "/path/model.h5"
    "target_column": "Class"
}

ml_options = {
    "credPath": "config.json", #Path to Azure ML credential files.
    "datasetinsertionType": "Manual", #Option: AzureML, Manual
    "registryOption": ["Model"], #To register model, add ["Model", "Dataset"] to register both model and datasets.
    "datasetUploadPath": "dataset-name", #To registere dataset on path.
    }
model = Model(secret_key, url).post_model(model_data, ml_options)
model.json()

---

ADD MODEL: MLFLOW

Add MLFlow Creds

from mmanager.mmanager import MLFlow
secret_key = 'Secret-Key'
url = 'URL' 

mlflow_cred_data = {
    "name": "", #eg:"Test Credentials"
    "aws_secret_access_key": "", #eg:"ueCepWaPlDIb/nATh7wYibgBMKXG3qn9PSZhk"
    "aws_access_key_id": "", #eg:"DO0MT6XN0CACQQ"
    "mlflow_s3_endpoint_url": "", #eg:"https://sfo3.digitaloceanspaces.com"
    "artifact_path": "", #eg:"pathtomodelfiles"
    "tracking_uri": "", #eg:"https://example.mlflow.com"
    "usecase": usecase_id #Usecase ID
}
mlflow_cred = MLFlow(secret_key, url).post_mlflow_creds(mlflow_cred_data)
mlflow_cred_id = mlflow_cred.json().get('id')
mlflow_cred.json()

Get MLFlow Creds

from mmanager.mmanager import MLFlow
secret_key = 'Secret-Key'
url = 'URL' 

creds_id = #eg:1
mlflow_cred = MLFlow(secret_key, url).get_mlflow_creds(mlflow_creds_id=creds_id)
mlflow_cred_dict = mlflow_cred.json()

usecase_id = mlflow_cred_dict.get('usecase')
mlflow_cred_id = mlflow_cred_dict.get('id')
mlflow_tracking_uri = mlflow_cred_dict.get('tracking_uri')
mlflow_aws_secret_access_key = mlflow_cred_dict.get('aws_secret_access_key')
mlflow_aws_access_key_id = mlflow_cred_dict.get('aws_access_key_id')
mlflow_s3_endpoint_url = mlflow_cred_dict.get('mlflow_s3_endpoint_url')

Download Datasets And Model Files From MLFlow Server

from mmanager.mmanager import MLFlow
secret_key = 'Secret-Key'
url = 'URL' 

mlflow_exp_name = experiment_name #Not Optional
run_id = None #Optional
artifact_path = None #Optional

# Note: This will download the files in temp location eg:/opt/tmp/dataset/train.csv
mlflow_datafiles_details = MLFlow(secret_key, url).download_dataset_model(mlflow_cred_id, mlflow_exp_name)
mlflow_datafiles_details_dict = mlflow_datafiles_details.json()

modelfile_dict = mlflow_datafiles_details_dict.get("model",{})
datasets_dict = mlflow_datafiles_details_dict.get("datasets",{})

# Note: File names might vary, as user will upload those in the MLFlow
trainfile_path = datasets_dict.get("train.csv", None)
testfile_path = datasets_dict.get("test.csv", None)
predfile_path = datasets_dict.get("pred.csv", None)
actualfile_path = datasets_dict.get("actual.csv", None)
modelfile_path = modelfile_dict.get("model_file", None)

mlflow_data_is_local = mlflow_datafiles_details_dict.get("is_local") #If the location of datasets are not in s3 bucket or any other external storages is_local = True.

Add Model

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL' 
model_data = {
    "project": usecase_id, #Project ID or Usecase ID
    "transformerType": "Classification", #Options: Classification, Regression, Forcasting
    "datasetinsertionType": "MLFlow", #Options: Manual, AzureML, MLFlow
    "training_dataset": trainfile_path, #path to csv file
    "test_dataset": testfile_path, #path to csv file
    "pred_dataset": predfile_path, #path to csv file
    "actual_dataset": actualfile_path, #path to csv file
    "model_file_path": modelfile_path, #path to model file|
    "is_mlflow_local": mlflow_data_is_local,
    "target_column": "", #Target Column, eg:Class
    "note": "", #Short description of Model, eg: MLFlow mmanager test model.
}
model = Model(secret_key, url).post_model(model_data)
model.json()

---

Update Model

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = Model_id #use model_id number to update
data = {
		"transformerType": "logistic",
		"target_column": "id",
		"training_dataset": "train.csv", #path to csv file
		"pred_dataset": "submissionsample.csv", #path to csv file
		"actual_dataset": "truth.csv", #path to csv file
		"test_dataset": "test.csv", #path to csv file
	}
Model(secret_key, url).patch_model(data, model_id)

---

Delete Model

---

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model_id" #use model_id number to delete
Model(secret_key,url).delete_model(model_id)

---

---

Get Model Details

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model_id" 
Model(secret_key,url).get_details(model_id)

---

---

Get Metrics

• Get latest metrics recorded under Model
• Metric Type
  • Developement Metric
  • Scoring Metric

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
metric = Model(secret_key,url).get_latest_metrics(model_id="Model-Id", metric_type="Metric-Type")

---

Generate Model Report

---

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model-Id" #use model_id number
Model(secret_key,url).generate_report(model_id)

---

Get Model Report

---

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model-Id" #use model_id number
all_report = Model(secret_key,url).get_all_reports(model_id=model_id)

---

Get Causal Analysis Graphs

---

Get Causal Discovery Graphs

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model-Id" #use model_id number
graph_type = "HeatMap" #Options : 3D_CausalDiscovery_Comparision, 2D_CausalDiscovery_Comparision, HeatMap
causal_dicovery = Model(secret_key, url).get_causal_discovery_graphs(model_id, graph_type=graph_type)
causal_dicovery

---

---

Get Causal Inference Graphs

Get Causal Inference Top 5 Effects

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model-Id" #use model_id number
graph_type = "coeff_graph" #Options : top_effect_p_values, top_effect_rsquared, coeff_graph
causal_inference_top5_effects = Model(secret_key, url).get_causal_inference_graphs(model_id, graph_type=graph_type)
causal_inference_top5_effects

---

Get Causal Inference Effects Comparision

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model-Id" #use model_id number
graph_type = "coeff_graph" #Options : top_effect_p_values, top_effect_rsquared, coeff_graph
treatment=""
outcome=""
causal_inference_effects_comparision = Model(secret_key, url).get_causal_inference_graphs(model_id, graph_type=graph_type, treatment=treatment, outcome=outcome)
causal_inference_effects_comparision

---

---

Get Causal Inference Correlations

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model-Id" #use model_id number
graph_type = "correlation_graph" #Options : correlation_graph, causal_correlation_summary
treatment=""
outcome=""
causal_inference_correlation = Model(secret_key, url).get_causal_inference_correlation(model_id, graph_type=graph_type, treatment=treatment, outcome=outcome)
causal_inference_correlation

---

Get Model Features

---

Display What If Analysis Tool

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model-Id" #use model_id number
what_if_analysis = Model(secret_key, url).get_wit(model_id)
what_if_analysis

---

Display Model Detail Tool

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model-Id" #use model_id number
model_detail_graph = Model(secret_key, url).get_netron(model_id)
model_detail_graph

---

Display Data Distribution Tool

from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model-Id" #use model_id number
model_detail_graph = Model(secret_key, url).get_data_distribution(model_id)
model_detail_graph

---

Build What If Analysis Tool

---

Add What If Resources For Image Classification Usecase

from mmanager.mmanager import WhatIf
secret_key = 'Secret-Key'
url = 'URL'
data = {
    "usecase":"",
    "model":"",
    "label":""
    "imgclass_datatype":"Local" #Resource Type: Options: Dicom(Pass Dicom data for image processing), Local (Upload data from the locally), Bucket (Get data from the storage bucket)
    "input_model":"", #If imgclass_datatype is Local (Model file should be in h5 extension. (eg: model.h5)).
    "input_zip":"", #If imgclass_datatype is Local (eg: histo.zip).
    "modelfile_url":"", #If imgclass_datatype is Bucket (Model file should be in h5 extension. (eg: https://bucket.example.com/model.h5)).
    "zip_url":"", #If imgclass_datatype is Bucket (eg: https://bucket.example.com/histo.zip).
}
dicom_fields = {
    "dicom_datatype":"", #Dicom Resource Link Type Options: Local(Upload dicom data from the locally), Bucket (Get data from the storage bucket)
    "dicom_zipfile":"", #Add your dicom zip file. (If dicom_datatype is Local.)
    "dicom_labelfile":"", #Add your dicom label file. eg: data.csv (If dicom_datatype is Local.)
    "dicom_url":"", #Add URL to your dicom file. (eg: https://bucket.example.com/histo_dicom.zip) (If dicom_datatype is Bucket.)
    "dicom_labelfile_url":"", #Add URL to your dicom label file. (eg: https://bucket.example.com/data.csv) (If dicom_datatype is Bucket.)
    "dicom_id_col":"", # Label File ID Column eg: id, entry etc.
    "dicom_target_col":"", #Label File Target Column eg:Finding, Label, Score etc.
}
# If imgclass_datatype is Dicom.
data.update({dicom_fields})
wit_imgcls_resource_files = Model(secret_key, url).post_img_cls_wit_files(data)
wit_imgcls_resource_files

---

Build What If Analysis

from mmanager.mmanager import WhatIf
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model-Id" #use model_id number
wit = Model(secret_key, url).build_wit(model_id)
wit