def train_pipeline(params: TrainingPipelineParams): logger.info("start training pipeline") data = read_data(params.input_data_path) logger.info(f"data readed from {params.input_data_path}") train_df, val_df = split_to_train_val(data, params.splitting_params) logger.debug( f"data splitted; train_df size: {train_df.shape}, val_df size: {val_df.shape}" ) feature_extractor = FeaturesExtractor(params.feature_params) X_train = feature_extractor.fit_transform(train_df) X_val = feature_extractor.transform(val_df) y_train = extract_target(train_df, params.feature_params) y_val = extract_target(val_df, params.feature_params) logger.info("features and target extracted") logger.debug( f"X_train size: {X_train.shape}, y_train size: {y_train.shape}, " f"X_val size: {X_val.shape}, y_val size: {y_val.shape}") model = train_model(X_train, y_train, params.train_params) logger.info(f"model {params.train_params.model_type} loaded") y_pred = predict_model(model, X_val) logger.debug(f"prediction done; y_pred size: {y_pred.shape}") metrics = evaluate_model(y_pred, y_val) logger.info(f"evaluation done; accuracy: {metrics['accuracy_score']}") path_to_model = save_model(model, params.output_model_path) logger.info(f"model saved to {path_to_model}") save_metrics(metrics, params.metric_path) logger.info(f"metrics saved to {params.metric_path}") return path_to_model, metrics
def train_pipeline( training_pipeline_params: TrainingPipelineParams) -> Tuple[str, dict]: logger.info(f"start train pipeline with params {training_pipeline_params}") data = read_data(training_pipeline_params.input_data_path) train_df, test_df = split_train_test_data( data, training_pipeline_params.splitting_params) feature_extractor = FeaturesExtractor( training_pipeline_params.feature_params) train_features = feature_extractor.fit_transform(train_df) train_target = extract_target(train_df, training_pipeline_params.feature_params) logger.info(f"train_features.shape is {train_features.shape}") logger.info("features and target created") model = train_model(train_features, train_target, training_pipeline_params.train_params) test_features = feature_extractor.transform(test_df) test_target = extract_target(test_df, training_pipeline_params.feature_params) logger.info(f"test_features.shape is {test_features.shape}") predicts = predict_model(model, test_features) metrics = evaluate_model(predicts, test_target) save_metrics(metrics, training_pipeline_params.metric_path) path_to_model = save_model(model, training_pipeline_params.output_model_path) logger.info(f"metrics is {metrics}") return path_to_model, metrics
def train_pipeline(training_pipeline_params: Params): # train, val data logger.info(f"start train pipeline with params {training_pipeline_params}") data = read_data(training_pipeline_params.train_data_path) logger.info(f"data.shape is {data.shape}") train_df, val_df = split_train_val_data( data, training_pipeline_params.splitting_params) logger.info(f"train_df.shape is {train_df.shape}") logger.info(f"val_df.shape is {val_df.shape}") # features extraction train_target = extract_target(train_df, training_pipeline_params.feature_params) transformer = Features_transformer(training_pipeline_params.feature_params) transformer.fit( train_df.drop( columns=training_pipeline_params.feature_params.target_col)) train_features = make_features( transformer, train_df.drop( columns=training_pipeline_params.feature_params.target_col)) logger.info(f"train_features.shape is {train_features.shape}") val_target = extract_target(val_df, training_pipeline_params.feature_params) val_features = make_features( transformer, val_df.drop( columns=training_pipeline_params.feature_params.target_col)) logger.info(f"val_features.shape is {val_features.shape}") # train and score model = train_model(train_features, train_target, training_pipeline_params.train_params) predicts = predict_model(model, val_features) metrics = evaluate_model(predicts, val_target) logger.info(f"metrics is {metrics}") # save path_to_feature_transformer = serialize_features_transformer( transformer, training_pipeline_params.features_transformer_path) path_to_model = serialize_model(model, training_pipeline_params.model_path) path_to_metrics = serialize_metrics(metrics, training_pipeline_params.metric_path) logger.info(f"transformer, model and metrics were saved") return path_to_feature_transformer, path_to_model, path_to_metrics, metrics
def main(): warnings.filterwarnings('ignore') params = read_training_pipeline_params(TRAIN_CONFIG_PATH) # load data data = read_data(params.input_data_path) X = FeaturesExtractor(params.feature_params).fit_transform(data) y = extract_target(data, params.feature_params) # determine models and its parameters logreg = LogisticRegression() logreg_grid_params = { "fit_intercept": [True, False], "max_iter": [100, 500, 1000], "C": np.logspace(-2, 1, 30), } trees = RandomForestClassifier() trees_grid_params = { "n_estimators": np.linspace(10, 100, 5).astype(int), "criterion": ["gini", "entropy"], "max_features": ["sqrt", "log2", .5, None], "min_samples_leaf": [1, 3, 5], } knn = KNeighborsClassifier() knn_grid_params = {"n_neighbors": [1, 3, 5, 7, 9, 11], "p": [1, 2, 3]} # unite model entities search_entities = [ ('logreg', logreg, logreg_grid_params), ('trees', trees, trees_grid_params), ('knn', knn, knn_grid_params), ] # run grid search and write best params and scores to file best_params_path = PATH_TO_BEST_MODEL_PARAMS with open(best_params_path, 'w') as fout: fout.write(f"model_name\tbest_params\taccuracy\n") for mname, model, grid_params in search_entities: best_params, score = best_model_params(model, grid_params, X, y) print( f"{mname}, {best_params}, {score}", file=sys.stderr, ) fout.write(f"{mname}\t{best_params}\t{score}\n")
def test_target_extraction(feature_params, synthetic_dataset): target = extract_target(synthetic_dataset, feature_params) assert isinstance(target, np.ndarray) assert target.shape == (len(synthetic_dataset), ) assert np.all(synthetic_dataset[feature_params.target_col] == target)
def train_data(synthetic_dataset, pipeline_params): feature_params = pipeline_params.feature_params X = FeaturesExtractor(feature_params).fit_transform(synthetic_dataset) y = extract_target(synthetic_dataset, feature_params) return X, y