def test_predict(): print("\n >>> start Predict()...") import sys sys.path.insert(0, '/Users/mikko/Documents/GitHub/talos') import talos x, y = talos.templates.datasets.iris() p = talos.templates.params.iris() model = talos.templates.models.iris x = x[:50] y = y[:50] scan_object = talos.Scan(x=x, y=y, params=p, model=model, experiment_name='test_iris', round_limit=2) predict = talos.Predict(scan_object) _preds = predict.predict(x, 'val_acc', False) _preds = predict.predict_classes(x, 'val_acc', False) print('finised Predict() \n')
scan_object = ta.Scan(X_train, y_train, model=lstm_model, params=p, experiment_name=experiment_name) r = ta.Reporting(scan_object) print(r.data[[ 'val_accuracy', 'epochs', 'batch_size', 'learning_rate', 'dense_neurons', "lstm_hspace" ]].sort_values('val_accuracy', ascending=False)) # number of iterations in k-fold validation folds = 5 # talos calls using the best model p = ta.Predict(scan_object, task='multi_class') e = ta.Evaluate(scan_object) accuracy_scores = e.evaluate(X_test, y_test, folds=folds, task='multi_label', metric='val_accuracy') predictions = p.predict(X_test, metric='val_accuracy') print('F1: ', np.mean(accuracy_scores)) def get_actual_class(row): if row.loc[0] == 1: return 0 elif row.loc[1] == 1: return 1
params_final = {'lr': {0.0001}, 'l1': {0}, 'l2': {0}, 'first_neuron': {32, 128}, 'hidden_layers': {1, 2}, 'batch_size': {32}, 'epochs': {1000000}, 'dropout': {0}, 'optimizer': {Adam}, 'losses': [mse], 'activation': {relu}} # Run the experiment os.chdir(path + "/Data/") t = ta.Scan(x=x_train, y=y_train, model=build_model, grid_downsample=1, val_split=0.3, params=params_final, dataset_name='POL', experiment_no='2_final') # Prediction p = ta.Predict(t) pred = p.predict(x_test, metric='val_loss') MSE = np.mean((y_test - pred)**2) print(MSE)
from talos.utils.gpu_utils import force_cpu if __name__ == '__main__': '''NOTE: test/core_tests/test_scan.py needs to be edited as well!''' # Scan scan_object = test_scan_object() # Reporting test_reporting_object(scan_object) start_time = str(time.strftime("%s")) p = ta.Predict(scan_object) p.predict(scan_object.x) p.predict_classes(scan_object.x) ta.Autom8(scan_object, scan_object.x, scan_object.y) ta.Evaluate(scan_object) ta.Deploy(scan_object, start_time) ta.Restore(start_time + '.zip') test_random_methods() fit_generator = generator(scan_object.x, scan_object.y, 20) force_cpu() TestCancer().test_scan_cancer_metric_reduction() TestCancer().test_scan_cancer_loss_reduction()
'epoch': [5, 10, 15], 'hidden_layers': [100, 500] } cnn_scan = talos.Scan(x=X, y=d_train_array, model=cnn_optimization, params=cnn_params, experiment_name='CNN_Optimization', round_limit=10, fraction_limit=0.05) cnn_analyze = talos.Analyze(cnn_scan) documentation_file_parameteropt.write( "CNN: Best parameters {}, reached score: {} \n".format( cnn_analyze.best_params('accuracy', ['accuracy', 'loss', 'val_loss']), cnn_analyze.high('accuracy'))) pred_cnn = talos.Predict(cnn_scan).predict(x_t, metric='val_f1score', asc=True) #evaluate the model cnn_evaluation_scores, cnn_cm = evaluation.multilabel_evaluation( d_test_array, label_binarizer.inverse_transform(pred_cnn), "CNN") documentation_file_modelopt.write(cnn_evaluation_scores) #deploy best model model_cnn = talos.Deploy(cnn_scan, "model_cnn_scibert", metric='val_accuracy') #build LSTM model and evaluate the model print("LSTM model evaluation") def lstm_optimization(x_train, y_train, x_test, y_test, params): """Randomized search to optimize parameters of Neural Network.""" optimization_model = models.Sequential() optimization_model.add(layers.LSTM(params['units'], return_sequences=True))
################################ # Generate a report r = ta.Reporting(h) # return the highest value for the validation accuracy and the best hyperparams to achieve it print(r.high('val_acc')) print(r.best_params('val_acc',3)) ################################ # compute confusion matrixes from sklearn.metrics import confusion_matrix import numpy as np np.set_printoptions(precision=3, suppress=True) p = ta.Predict(h) #Confusion matrix and class distribution for train data train_classes = p.predict_classes(train_features) train_matrix = confusion_matrix(train_classes,train_labels_int) print("\nConfusion matrix for classifying train data:") print(train_matrix) print("\nDistribution of true labels for train data:") train_dist = np.sum(train_matrix,axis=0) print(train_dist/sum(train_dist)) print("\nDistribution of predicted labels for train data:") train_dist_pred = np.sum(train_matrix,axis=1) print(train_dist_pred/sum(train_dist_pred)) #Confusion matrix for validation data