np.random.seed(1337) # for reproducibility
from sklearn.metrics.classification import accuracy_score
from dbn.tensorflow import SupervisedDBNClassification
from Rafd import Rafd
# Splitting data
rafd = Rafd("entrenamiento/")
X_train, X_test, Y_train, Y_test = rafd.getData()
# Training
classifier = SupervisedDBNClassification(hidden_layers_structure=[256, 256],
learning_rate_rbm=0.05,
learning_rate=0.001,
n_epochs_rbm=15,
n_iter_backprop=100,
batch_size=32,
activation_function='sigmoid',
dropout_p=0.2)
classifier.fit(X_train, Y_train)
# Save the model
classifier.save('model.pkl')
# Restore it
classifier = SupervisedDBNClassification.load('model.pkl')
# Test
Y_pred = classifier.predict(X_test)
print('Done.\nAccuracy: %f' % accuracy_score(Y_test, Y_pred))
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics.classification import accuracy_score
from dbn.tensorflow import SupervisedDBNClassification
from keras.utils import np_utils
labels = np.loadtxt('label_205.txt')
encoded_seq = np.loadtxt('encoded_seq_205.txt')
X_train, X_test, Y_train, Y_test = train_test_split(encoded_seq,
labels,
test_size=0.2)
classifier = SupervisedDBNClassification(hidden_layers_structure=[256, 256],
learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=10,
n_iter_backprop=100,
batch_size=100,
activation_function='sigmoid',
dropout_p=0.2)
classifier.fit(X_train, Y_train)
classifier.save('dbn.pkl')
Y_pred = classifier.predict(X_test)
print('Done.\nAccuracy: %f' % accuracy_score(Y_test, Y_pred))
print('x_test', x_test.shape)
print('y_test', y_test.shape)
#x_test = x_test[:2000]
#y_test = y_test[:2000]
#print('x_train: ', x_train.shape[0])
#print('x_test number: ', x_test.shape[0])
# Training
classifier = SupervisedDBNClassification(
hidden_layers_structure=[2304, 256, 64],
learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=10,
n_iter_backprop=60,
batch_size=64,
activation_function='relu',
dropout_p=0.2)
classifier.fit(x_train, y_train)
# Save the model
classifier.save('models/model_mnist.pkl')
# Restore it
#classifier = SupervisedDBNClassification.load('model.pkl')
# Test
Y_pred = classifier.predict(x_test)
print('Done.\nAccuracy: %f' % accuracy_score(y_test, Y_pred))
n_iter_backprop=100,
batch_size=100,
activation_function='relu',
dropout_p=0.2)
# start counting time for training
time_train_start = time.clock()
# Training
classifier.fit(X_train, y_train)
# print training time
time_train_end = time.clock()
print("Training finished, training time: %g seconds \n" %
(time_train_end - time_train_start))
'''
# Save the model
classifier.save('model.pkl')
# Restore it
classifier = SupervisedDBNClassification.load('model.pkl')
'''
# start counting time for testing
time_test_start = time.clock()
# Test
y_pred = classifier.predict(X_test)
print('Testing finished.\nAccuracy: %f' % accuracy_score(y_test, y_pred))
# print testing time
time_test_end = time.clock()
X_train, X_test, Y_train, Y_test = train_test_split(X, y, test_size = 0.22, random_state = 101)
#'''
classifier2 = SupervisedDBNClassification(hidden_layers_structure=[8, 50],
learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=30,
n_iter_backprop=100,
batch_size=64,
activation_function='relu',
dropout_p=0.2)
classifier2.fit(X_train, Y_train)
# Save the model
classifier2.save('models/breast_cancer_origin_3.pkl')
# Restore it
#classifier2 = SupervisedDBNClassification.load('models/breast_cancer_origin_2.pkl')
# Test
#X_test = min_max_scaler.transform(X_test)
Y_pred = classifier2.predict(X_test)
print('Accuracy: %f' % accuracy_score(Y_test, Y_pred))
'''
rfc = RandomForestClassifier(n_estimators=201)
rfc.fit(X_train,Y_train)
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
mlp = SupervisedDBNClassification(hidden_layers_structure=[19, 30, 19],
learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=10,
n_iter_backprop=50,
batch_size=32,
activation_function='relu',
dropout_p=0.2)
mlp.fit(X_train, y_train)
# Save the model
mlp.save('model.pkl')
# Restoreit
mlp = SupervisedDBNClassification.load('model.pkl')
predictions = mlp.predict(X_test)
RMSE_sum = 0
list = []
for x in range(0, len(X_test)):
RMSE_sum = RMSE_sum + ((y_test[x] - predictions[x])**2)
list.append(abs(y_test[x] - predictions[x]))
RMSE = math.sqrt(RMSE_sum / len(X_test))
print("RMSE :", RMSE)
def run(params):
# ##################### get parameters and define logger ################
# device
os.environ['CUDA_VISIBLE_DEVICES'] = str(params.gpu)
# get parameters
data_name = params.data.data_name
data_dir = params.data.data_dir
target_dir = params.data.target_dir
train_prop = params.data.train_prop
val_prop = params.data.val_prop
train_params = params.train
method_name = params.method_name
result_dir = params.result_dir
folder_level = params.folder_level
train_prop = train_prop if train_prop < 1 else int(train_prop)
val_prop = val_prop if val_prop < 1 else int(val_prop)
result_root = result_dir
local_v = locals()
for s in folder_level:
result_dir = check_path(os.path.join(result_dir, str(local_v[s])))
# define output dirs
acc_dir = os.path.join(result_root, 'accuracy.csv')
log_dir = os.path.join(result_dir, 'train.log')
model_dir = os.path.join(result_dir, 'weights.pkl')
# soft_dir = os.path.join(result_dir, 'soft_label.mat')
# loss_dir = os.path.join(result_dir, 'loss_curve.png')
# define logger
logger = define_logger(log_dir)
# print parameters
num1 = 25
num2 = 100
logger.info('%s begin a new training: %s %s' %
('#' * num1, method_name, '#' * num1))
params_str = recur_str_dict_for_show(params, total_space=num2)
logger.info('show parameters ... \n%s' % params_str)
# ########################### get data, train ############################
logger.info('get data ...')
mask_dir = os.path.dirname(data_dir)
data, target = read_data(data_dir, target_dir)
train_mask, val_mask, test_mask = load_masks(mask_dir, target, train_prop,
val_prop)
x_train, y_train = get_vector_samples(data, target, train_mask)
logger.info('get model ...')
from dbn.tensorflow import SupervisedDBNClassification
classifier = SupervisedDBNClassification(**train_params)
logger.info('begin to train ...')
s = time.time()
classifier.fit(x_train, y_train)
e = time.time()
train_time = e - s
logger.info('training time: %.4fs' % train_time)
logger.info('save model ...')
classifier.save(model_dir)
# ########################### predict, output ###########################
all_data = data.reshape(-1, data.shape[1] * data.shape[2]).T
classifier = SupervisedDBNClassification.load(model_dir)
logger.info('begin to predict ...')
s = time.time()
pred = classifier.predict(all_data)
pred = np.array(pred)
pred = pred.reshape(target.shape) + 1
e = time.time()
pred_time = (e - s)
logger.info('predicted time: %.4fs' % pred_time)
# output predicted map(png/mat), accuracy table and other records
logger.info('save classification maps etc. ...')
train_records = {
'train_time': '%.4f' % train_time,
'pred_time': '%.4f' % pred_time
}
ro = ResultOutput(pred,
data,
target,
train_mask,
val_mask,
test_mask,
result_dir,
acc_dir,
hyper_params=params,
train_records=train_records)
ro.output()
dropout_p=0.2)
# Split Data
X, Y = get_dataset(tz)
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.2,
random_state=0)
print('Size of training set == {}, Size of testing set == {}\n'.format(
len(X_train), len(X_test)))
start_time = timer()
tot_start = start_time
Matt_Net.pre_train(X_train)
print('Time to pretrain == {:5.3f} seconds\n'.format(timer() - start_time))
start_time = timer()
Matt_Net.fit(X_train, Y_train, False)
print('Time to fit == {:5.3f} seconds\n'.format(timer() - start_time))
print('Total time == {:5.3f} seconds\n'.format(timer() - tot_start))
Matt_Net.save('train/Matt_Net_Zone_{}.pkl'.format(tz))
Y_pred = Matt_Net.predict(X_test)
start_time = timer()
score = accuracy_score(Y_test, Y_pred)
print(
'Done, time to predict == {:5.3}\nAccuracy == {} for zone {}\n'.format(
timer() - start_time, score, tz))
del Matt_Net