Inheritance diagram for MedMicNet:

Public Member Functions
	MedMicNet (void *params)

	MedMicNet (MedMicNetParams &params)

int	init (void *params)

int	init_from_string (string initialization_text)
	The parsed fields from init command.

int	init (map< string, string > &mapper)
	MedMicNet:: init map :: not supported, only init_from_string supported.

int	set_params (map< string, string > &mapper)

void	init_defaults ()

int	Learn (float x, float y, const float *w, int nsamples, int nftrs)
	Learn should be implemented for each model.

int	Predict (float x, float &preds, int nsamples, int nftrs) const
	Predict should be implemented for each model.

int	learn (MedMat< float > &x, MedMat< float > &y, vector< float > &wgt)

int	learn (MedMat< float > &x, MedMat< float > &y)

int	predict (MedMat< float > &x, vector< float > &preds) const

void	prepare_predict_single ()

void	predict_single (const vector< float > &x, vector< float > &preds) const

int	n_preds_per_sample () const
	Number of predictions per sample. typically 1 - but some models return several per sample (for example a probability vector)

Public Member Functions inherited from MedPredictor
int	init_from_string (string initialization_text)

virtual void	print (FILE *fp, const string &prefix, int level=0) const

virtual int	denormalize_model (float f_avg, float f_std, float label_avg, float label_std)

int	learn (float x, float y, int nsamples, int nftrs)
	simple no weights call

virtual int	learn (MedMat< float > &x, MedMat< float > &y, const vector< float > &wgts)
	MedMat x,y : will transpose/normalize x,y if needed by algorithm The convention is that untransposed mats are always samples x features, and transposed are features x samples.

int	learn (MedMat< float > &x, MedMat< float > &y)
	MedMat x,y : will transpose/normalize x,y if needed by algorithm The convention is that untransposed mats are always samples x features, and transposed are features x samples.

int	learn (MedMat< float > &x, vector< float > &y, const vector< float > &wgts)
	MedMat x, vector y: will transpose normalize x if needed (y assumed to be normalized)

int	learn (MedMat< float > &x, vector< float > &y)
	MedMat x, vector y: will transpose normalize x if needed (y assumed to be normalized)

int	learn (vector< float > &x, vector< float > &y, const vector< float > &wgts, int n_samples, int n_ftrs)
	vector x,y: transpose/normalizations not done.

int	learn (vector< float > &x, vector< float > &y, int n_samples, int n_ftrs)
	vector x,y: transpose/normalizations not done.

int	predict (vector< float > &x, vector< float > &preds, int n_samples, int n_ftrs) const

int	threaded_predict (MedMat< float > &x, vector< float > &preds, int nthreads) const

int	learn (const MedFeatures &features)

int	learn (const MedFeatures &features, vector< string > &names)

virtual int	predict (MedFeatures &features) const

virtual void	calc_feature_importance (vector< float > &features_importance_scores, const string &general_params)
	Feature Importance - assume called after learn.

virtual void	calc_feature_importance (vector< float > &features_importance_scores, const string &general_params, const MedFeatures *features)

virtual void	calc_feature_contribs (MedMat< float > &x, MedMat< float > &contribs)
	Feature contributions explains the prediction on each sample (aka BUT_WHY)

virtual void	calc_feature_contribs_conditional (MedMat< float > &mat_x_in, unordered_map< string, float > &contiditional_variables, MedMat< float > &mat_x_out, MedMat< float > &mat_contribs)

virtual void	export_predictor (const string &output_fname)

int	learn_prob_calibration (MedMat< float > &x, vector< float > &y, vector< float > &min_range, vector< float > &max_range, vector< float > &map_prob, int min_bucket_size=10000, float min_score_jump=0.001, float min_prob_jump=0.005, bool fix_prob_order=false)
	calibration for probability using training data

int	convert_scores_to_prob (const vector< float > &preds, const vector< float > &min_range, const vector< float > &max_range, const vector< float > &map_prob, vector< float > &probs) const
	If you have ran learn_prob_calibration before, you have min_range,max_range,map_prob from This function - that is used to convert preds to probs.

int	learn_prob_calibration (MedMat< float > &x, vector< float > &y, int poly_rank, vector< double > &params, int min_bucket_size=10000, float min_score_jump=0.001)
	Will create probability bins using Platt scale method.

template<class T , class L >
int	convert_scores_to_prob (const vector< T > &preds, const vector< double > &params, vector< L > &converted) const
	Converts probability from Platt scale model.

virtual bool	predict_single_not_implemented ()
	Prepartion function for fast prediction on single item each time.

virtual void	predict_single (const vector< double > &x, vector< double > &preds) const

virtual void	calc_feature_importance_shap (vector< float > &features_importance_scores, string &importance_type, const MedFeatures *features)

void *	new_polymorphic (string derived_class_name)
	for polymorphic classes that want to be able to serialize/deserialize a pointer * to the derived class given its type one needs to implement this function to return a new to the derived class given its type (as in my_type)

size_t	get_predictor_size ()

size_t	predictor_serialize (unsigned char *blob)

Public Member Functions inherited from SerializableObject
virtual int	version () const
	Relevant for serializations.

virtual string	my_class_name () const
	For better handling of serializations it is highly recommended that each SerializableObject inheriting class will implement the next method.

virtual void	serialized_fields_name (vector< string > &field_names) const
	The names of the serialized fields.

virtual void	pre_serialization ()

virtual void	post_deserialization ()

virtual size_t	get_size ()
	Gets bytes sizes for serializations.

virtual size_t	serialize (unsigned char *blob)
	Serialiazing object to blob memory. return number ob bytes wrote to memory.

virtual size_t	deserialize (unsigned char *blob)
	Deserialiazing blob to object. returns number of bytes read.

size_t	serialize_vec (vector< unsigned char > &blob)

size_t	deserialize_vec (vector< unsigned char > &blob)

virtual size_t	serialize (vector< unsigned char > &blob)

virtual size_t	deserialize (vector< unsigned char > &blob)

virtual int	read_from_file (const string &fname)
	read and deserialize model

virtual int	write_to_file (const string &fname)
	serialize model and write to file

virtual int	read_from_file_unsafe (const string &fname)
	read and deserialize model without checking version number - unsafe read

int	init_from_string (string init_string)
	Init from string.

int	init_params_from_file (string init_file)

int	init_param_from_file (string file_str, string &param)

int	update_from_string (const string &init_string)

virtual int	update (map< string, string > &map)
	Virtual to update object from parsed fields.

virtual string	object_json () const

Data Fields
micNet	mic

MedMicNetParams	mic_params
	Parameters.

Data Fields inherited from MedPredictor
MedPredictorTypes	classifier_type
	The Predicotr enum type.

bool	transpose_for_learn
	True if need to transpose before learn.

bool	normalize_for_learn
	True if need to normalize before learn.

bool	normalize_y_for_learn
	True if need to normalize labels before learn.

bool	transpose_for_predict
	True if need to transpose before predict.

bool	normalize_for_predict
	True if need to normalize before predict.

vector< string >	model_features
	The model features used in Learn, to validate when caling predict.

int	features_count = 0
	The model features count used in Learn, to validate when caling predict.

Additional Inherited Members
Static Public Member Functions inherited from MedPredictor
static MedPredictor *	make_predictor (string model_type)

static MedPredictor *	make_predictor (MedPredictorTypes model_type)

static MedPredictor *	make_predictor (string model_type, string params)

static MedPredictor *	make_predictor (MedPredictorTypes model_type, string params)

Protected Member Functions inherited from MedPredictor
void	prepare_x_mat (MedMat< float > &x, const vector< float > &wgts, int &nsamples, int &nftrs, bool transpose_needed) const

void	predict_thread (void *p) const

Member Function Documentation

◆ init() [1/2]

int MedMicNet::init ( map< string, string > & mapper )

inlinevirtual

MedMicNet:: init map :: not supported, only init_from_string supported.

Reimplemented from MedPredictor.

◆ init() [2/2]

int MedMicNet::init ( void * params )

inlinevirtual

Reimplemented from MedPredictor.

◆ init_defaults()

void MedMicNet::init_defaults ( )

inlinevirtual

Reimplemented from MedPredictor.

◆ init_from_string()

int MedMicNet::init_from_string ( string initialization_text )

inline

The parsed fields from init command.

        if (fields[i] == "A") def_A = stof(fields[++i]);
        if (fields[i] == "B") def_B = stof(fields[++i]);
        if (fields[i] == "lambda") def_lambda = stof(fields[++i]);
        if (fields[i] == "momentum") def_momentum = stof(fields[++i]);
        if (fields[i] == "batch_size") batch_size = stoi(fields[++i]);
        if (fields[i] == "max_norm") max_wgt_norm = stof(fields[++i]);
        if (fields[i] == "min_norm") min_wgt_norm = stof(fields[++i]);
        if (fields[i] == "wgt_std") weights_init_std = stof(fields[++i]);
        if (fields[i] == "rate_decay") rate_decay = stof(fields[++i]);
        if (fields[i] == "n_categ") n_categ = stoi(fields[++i]);
        if (fields[i] == "n_per_categ") n_per_categ = stoi(fields[++i]);
        if (fields[i] == "nfeat") nfeat = stoi(fields[++i]);
        if (fields[i] == "n_norm") n_norm_layers = stoi(fields[++i]);
        if (fields[i] == "norm_facor") normalization_factor = stof(fields[++i]);
        if (fields[i] == "sparse") sparse_zero_prob = stof(fields[++i]);
        if (fields[i] == "loss_type") loss_type = fields[++i];
        if (fields[i] == "net_type") net_type = fields[++i];
        if (fields[i] == "min_epochs") min_epochs = stoi(fields[++i]);
        if (fields[i] == "max_epochs") max_epochs = stoi(fields[++i]);
        if (fields[i] == "n_back") n_back = stoi(fields[++i]);
        if (fields[i] == "min_improve") min_improve_n_back = stof(fields[++i]);
        if (fields[i] == "n_preds_per_sample") n_preds_per_sample = stoi(fields[++i]);
        if (fields[i] == "pred_class") pred_class = stoi(fields[++i]);
        if (fields[i] == "last_layer") last_layer_to_keep = stoi(fields[++i]);
        //if (fields[i] == "learning_rate") def_learning_rate = stof(fields[++i]);
 
        learning_rates.resize(500, def_learning_rate);
        if (fields[i] == "learning_rate") {
            string s = fields[++i];
            vector<string> f;
            boost::split(f, s, boost::is_any_of("-/#"));
            int k = 0;
            for (int j = 0; j < f.size(); j++)
                learning_rates[k++] = stof(f[j]);
            if (k > 0) {
                for (int j = k; j < learning_rates.size(); j++)
                    learning_rates[j] = learning_rates[k - 1];
            }
        }
 
        if (fields[i] == "hidden") {
            string s = fields[++i];
            vector<string> f;
            boost::split(f, s, boost::is_any_of("-/#"));
            for (int j = 0; j < f.size(); j++)
                n_hidden.push_back(stoi(f[j]));
        }
        if (fields[i] == "dropout") {
            string s = fields[++i];
            vector<string> f;
            boost::split(f, s, boost::is_any_of("-/#"));
            for (int j = 0; j < f.size(); j++)
                dropout_in_probs.push_back(stof(f[j]));
        }
 
        if (fields[i] == "samp_ratio") {
            string s = fields[++i];
            vector<string> f;
            boost::split(f, s, boost::is_any_of("-/#"));
            for (int j = 0; j < f.size(); j++)
                samp_ratio.push_back(stof(f[j]));
        }

◆ Learn()

int MedMicNet::Learn	(	float *	x,
		float *	y,
		const float *	w,
		int	n_samples,
		int	n_ftrs
	)

inlinevirtual

Learn should be implemented for each model.

This API always assumes the data is already normalized/transposed as needed, and never changes data in x,y,w. method should support calling with w=NULL.

Reimplemented from MedPredictor.

◆ n_preds_per_sample()

int MedMicNet::n_preds_per_sample ( ) const

inlinevirtual

Number of predictions per sample. typically 1 - but some models return several per sample (for example a probability vector)

Reimplemented from MedPredictor.

◆ Predict()

int MedMicNet::Predict	(	float *	x,
		float *&	preds,
		int	n_samples,
		int	n_ftrs
	)		const

inlinevirtual

Predict should be implemented for each model.

This API assumes x is normalized/transposed if needed. preds should either be pre-allocated or NULL - in which case the predictor should allocate it to the right size.

Reimplemented from MedPredictor.

◆ predict()

int MedMicNet::predict	(	MedMat< float > &	x,
		vector< float > &	preds
	)		const

inlinevirtual

Reimplemented from MedPredictor.

◆ predict_single()

void MedMicNet::predict_single	(	const vector< float > &	x,
		vector< float > &	preds
	)		const

virtual

Reimplemented from MedPredictor.

◆ prepare_predict_single()

void MedMicNet::prepare_predict_single ( )

virtual

Reimplemented from MedPredictor.

◆ set_params()

int MedMicNet::set_params ( map< string, string > & mapper )

inlinevirtual

Reimplemented from MedPredictor.

The documentation for this class was generated from the following files:

Internal/MedAlgo/MedAlgo/MedMicNet.h
Internal/MedAlgo/MedAlgo/MedAlgo.cpp

Public Member Functions

Data Fields

Additional Inherited Members

Member Function Documentation

◆ init() [1/2]

◆ init() [2/2]

◆ init_defaults()

◆ init_from_string()

◆ Learn()

◆ n_preds_per_sample()

◆ Predict()

◆ predict()

◆ predict_single()

◆ prepare_predict_single()

◆ set_params()