def test_predict_from_model_array(self): params = nn_params.copy() params.update({'nclasses': n_classes}) optimizer = GenericSolver(**solver_param) datasets.dump_svmlight_file(xtr, ytr, tr_f) datasets.dump_svmlight_file(xte, yte, te_f) # Train model clf = MLP(**params) clf.fit(xtr_arr, validation_data=[xte_arr], solver=optimizer) y_pred_tr = clf.predict(xtr_arr) y_pred_te = clf.predict(xte_arr) # Load from tained model params = nn_params.copy() params.update({ 'finetuning': True, 'template': None, 'nclasses': n_classes }) clf = MLP(sname=clf.sname, repository=clf.model['repository'], **params) assert np.array_equal(y_pred_tr, clf.predict(xtr_arr)) assert np.array_equal(y_pred_te, clf.predict(xte_arr)) os_utils._remove_files([tr_f, te_f])
def test_classification(self): params = {'gpu': True, 'nclasses': n_classes} params.update(connec_param) train_path = os.path.abspath('x_train.svm') test_path = os.path.abspath('x_test.svm') datasets.dump_svmlight_file(x_train, y_train, train_path) datasets.dump_svmlight_file(x_test, y_test, test_path) clfs = [ [{ 'X': train_path }, test_path, MLPfromSVM(**params)], [{ 'X': [train_path, test_path] }, test_path, MLPfromSVM(**params)], [{ 'X': train_path }, test_path, LRfromSVM(**params)], [{ 'X': [train_path, test_path] }, test_path, LRfromSVM(**params)], [{ 'X': x_train, 'Y': y_train, 'validation_data': [(x_test, y_test)] }, x_test, MLPfromArray(**params)], [{ 'X': csr_matrix(x_train), 'Y': y_train, 'validation_data': [(csr_matrix(x_test), y_test)] }, x_test, MLPfromArray(**params)], [{ 'X': x_train, 'Y': y_train, 'validation_data': [(x_test, y_test)] }, x_test, LRfromArray(**params)], [{ 'X': csr_matrix(x_train), 'Y': y_train, 'validation_data': [(csr_matrix(x_test), y_test)] }, x_test, LRfromArray(**params)], ] for fit_param, predict_params, clf in clfs: clf.fit(**fit_param) acc = metrics.accuracy_score(y_test, clf.predict(predict_params)) assert acc > 0.95 os_utils._remove_files([train_path, test_path])
def test_predict_from_model(self): snames = ['svm_predict_from_model', 'array_predict_from_model'] model_repo = [ os.path.abspath('model_svm'), os.path.abspath('model_array') ] params = {'nclasses': n_classes, 'gpu': True} params.update(connec_param) train_path = os.path.abspath('x_train.svm') test_path = os.path.abspath('x_test.svm') datasets.dump_svmlight_file(x_train, y_train, train_path) datasets.dump_svmlight_file(x_test, y_test, test_path) # We make sure model repo does not exist for folder in model_repo: if os.path.exists(folder): os_utils._remove_dirs([folder]) os_utils._create_dirs(model_repo) # Create model, make sure the sname is not used by the server clf_svm = MLPfromSVM(sname=snames[0], repository=model_repo[0], **params) clf_array = MLPfromArray(sname=snames[1], repository=model_repo[1], **params) clf_svm.fit([train_path, test_path], iterations=300) clf_array.fit(x_train, y_train, validation_data=[(x_test, y_test)], iterations=300) y_pred_svm = clf_svm.predict(test_path) y_pred_array = clf_array.predict(x_test) # Load from existing model params = {'nclasses': n_classes, 'finetuning': True, 'template': None} params.update(connec_param) clf_svm = MLPfromSVM(sname=snames[0], repository=model_repo[0], **params) clf_array = MLPfromArray(sname=snames[1], repository=model_repo[1], **params) assert np.array_equal(y_pred_svm, clf_svm.predict(test_path)) assert np.array_equal(y_pred_array, clf_array.predict(x_test)) os_utils._remove_files([train_path, test_path]) os_utils._remove_dirs(model_repo)
def test_lmdb_creation(self): params = nn_params.copy() params.update({'nclasses': n_classes}) # Create dataset X, Y = datasets.load_digits(return_X_y=True) X = preprocessing.StandardScaler().fit_transform(X) x_train, x_test, y_train, y_test = model_selection.train_test_split( X, Y, test_size=test_size, random_state=seed) # Save data in .svm format tr_svm_f, tr_lmdb_f = os.path.abspath('x_train.svm'), os.path.abspath( 'x_train.lmdb') te_svm_f, te_lmdb_f = os.path.abspath('x_test.svm'), os.path.abspath( 'x_test.lmdb') vocab_path = os.path.abspath('vocab.dat') datasets.dump_svmlight_file(x_train, y_train, tr_svm_f) datasets.dump_svmlight_file(x_test, y_test, te_svm_f) lmdb_utils.create_lmdb_from_svm(svm_path=tr_svm_f, lmdb_path=tr_lmdb_f, vocab_path=vocab_path, **params) lmdb_utils.create_lmdb_from_svm(svm_path=te_svm_f, lmdb_path=te_lmdb_f, **params) tr_lmdb = SVMConnector(path=tr_svm_f, lmdb_path=tr_lmdb_f, vocab_path=vocab_path) te_lmdb = SVMConnector(path=te_svm_f, lmdb_path=te_lmdb_f) optimizer = GenericSolver(solver_type='SGD', base_lr=0.01, iterations=100) clf = MLP(**params) clf.fit(tr_lmdb, validation_data=[te_lmdb], solver=optimizer) ytr_prob = clf.predict_proba(tr_lmdb) acc = metrics.accuracy_score(y_train, ytr_prob.argmax(-1)) assert acc > 0.7 os_utils._remove_files([tr_svm_f, te_svm_f, vocab_path]) os_utils._remove_dirs([tr_lmdb_f, te_lmdb_f])
def test_classification(self): params = nn_params.copy() params.update({'nclasses': n_classes}) optimizer = GenericSolver(**solver_param) datasets.dump_svmlight_file(xtr, ytr, tr_f) datasets.dump_svmlight_file(xte, yte, te_f) clfs = [ # array connector without validation set [xtr_arr, [], MLP(**params)], [xtr_arr, [], LR(**params)], # sparse array connector without validation set [xtr_sparse, [], MLP(**params)], [xtr_sparse, [], LR(**params)], # svm connector without validation set [xtr_svm, [], MLP(**params)], [xtr_svm, [], LR(**params)], # array connector with validation set [xtr_arr, [xte_arr], MLP(**params)], [xtr_arr, [xte_arr], LR(**params)], # svm connector with validation set [xtr_svm, [xte_svm], MLP(**params)], [xtr_svm, [xte_svm], LR(**params)], ] for tr_data, te_data, clf in clfs: clf.fit(tr_data, te_data, optimizer) y_pred = clf.predict(tr_data) acc = metrics.accuracy_score(ytr, y_pred) print(acc) assert acc > 0.7 os_utils._remove_files([tr_f, te_f])
service_parameters_input=service_parameters_input, service_parameters_mllib=service_parameters_mllib, service_parameters_output=service_parameters_output, model=model, tmp_dir=None) train_parameters_input = {"db": True}, train_parameters_output = {"measure": ["accp", "mcll"]}, train_parameters_mllib = { "gpu": service_parameters_mllib["gpu"], "solver": { "iterations": 100, "base_lr": 0.01, "solver_type": "SGD" }, "net": { "batch_size": 128 }, } clf._train([tr_f], train_parameters_input, train_parameters_mllib, train_parameters_output, display_metric_interval=1, async=True) json_dump = clf._predict_proba([tr_f], parameters_output={"best": -1}) os_utils._remove_files([tr_f])
y_train, validation_data=[(x_test, y_test)], iterations=1000, test_interval=10) del clf_svm del clf_array # Load from existing model params = { 'host': 'localhost', 'port': 8081, 'nclasses': 10, 'finetuning': True, 'template': None } clf_svm = MLPfromSVM(sname=snames[0], repository=model_repo[0], **params) clf_array = MLPfromArray(sname=snames[1], repository=model_repo[1], **params) for X, clf in [[test_path, clf_svm], [x_test, clf_array]]: y_prob = clf.predict_proba(X) y_pred = clf.predict(X) print('-' * 50) print("Model: {}".format(clf)) print("Model: Accuracy: {}, Loss: {}".format( metrics.accuracy_score(y_test, y_pred), metrics.log_loss(y_test, y_prob))) os_utils._remove_files([train_path, test_path]) os_utils._remove_dirs(model_repo)