def main():
train_data, train_label = read_data("TRAIN", IMAGE_SIZE)
test_data, test_label = read_data("TEST", IMAGE_SIZE)
# flat data
flatten_train_data = train_data.reshape(np.size(train_data, 0), -1)
flatten_test_data = test_data.reshape(np.size(test_data, 0), -1)
flatten_train_data, train_label = nudge_dataset(flatten_train_data,
train_label)
# flatten_train_data = np.concatenate([flatten_train_data, gaussian_filter1d(flatten_train_data, sigma=0.5)])
# train_label = np.concatenate([train_label for _ in range(2)])
# normalize data
flatten_train_data = min_max_normalize(flatten_train_data)
flatten_test_data = min_max_normalize(flatten_test_data)
expanded_train_data = np.expand_dims(
flatten_train_data.reshape((-1, ) + IMAGE_SIZE), -1)
expanded_test_data = np.expand_dims(
flatten_test_data.reshape((-1, ) + IMAGE_SIZE), -1)
dbn = SupervisedDBNClassification(hidden_layers_structure=[128, 64],
learning_rate_rbm=0.001,
learning_rate=0.001,
n_epochs_rbm=20,
n_iter_backprop=10000,
batch_size=32,
activation_function='relu',
dropout_p=0.2)
dbn.fit(flatten_train_data, train_label)
evaluate(np.asarray(list(dbn.predict(flatten_test_data))), test_label,
"DBN")
def fractal_modeldata(filename):
scores = []
print(filename)
X, Y = loaddata(filename, 31)
np.random.seed(13)
indices = np.random.permutation(2030)
test_size = int(0.1 * len(indices))
X_train = X[indices[:-test_size]]
Y_train = Y[indices[:-test_size]]
X_test = X[indices[-test_size:]]
Y_test = Y[indices[-test_size:]]
# relu, sigmoid
classifier = SupervisedDBNClassification(hidden_layers_structure=[30, 30],
learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=10,
n_iter_backprop=1000,
batch_size=16,
activation_function='sigmoid',
dropout_p=0.1,
verbose=0)
classifier.fit(X_train, Y_train)
Y_pred = classifier.predict(X_test)
print(accuracy_score(Y_test, Y_pred)*100)
print(classification_report(Y_test, Y_pred))
def dbn(train_x, train_y, num_classes=3):
model = SupervisedDBNClassification(learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=10,
n_iter_backprop=100,
batch_size=32,
activation_function='relu',
dropout_p=0.2)
model.fit(train_x, train_y)
return model
def create_model():
classifier = SupervisedDBNClassification(hidden_layers_structure=[256, 256],
learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=10,
n_iter_backprop=500,
batch_size=32,
activation_function='relu',
dropout_p=0.1,verbose=False)
return classifier
def fractal_modeldata(filename):
scores = []
print(filename)
X, Y = loaddata(filename, 99)
for i in range(1):
np.random.seed(13)
indices = np.random.permutation(1000)
test_size = int(0.1 * len(indices))
X_train = X[indices[:-test_size]]
Y_train = Y[indices[:-test_size]]
X_test = X[indices[-test_size:]]
Y_test = Y[indices[-test_size:]]
# relu, sigmoid
classifier = SupervisedDBNClassification(
hidden_layers_structure=[256, 256],
learning_rate_rbm=0.05,
learning_rate=0.2,
n_epochs_rbm=30,
n_iter_backprop=2000,
batch_size=16,
activation_function='sigmoid',
dropout_p=0.1,
verbose=0)
classifier.fit(X_train, Y_train)
Y_pred = classifier.predict(X_test)
scores.append(accuracy_score(Y_test, Y_pred))
print(classification_report(Y_test, Y_pred))
fpr, tpr, threshold = roc_curve(Y_test, Y_pred)
roc_auc = auc(fpr, tpr)
plt.title('Receiver Operating Characteristic')
plt.plot(fpr, tpr, 'b', label='AUC = %0.2f' % roc_auc)
plt.legend(loc='lower right')
plt.plot([0, 1], [0, 1], 'r--')
plt.xlim([0, 1])
plt.ylim([0, 1])
plt.ylabel('True Positive Rate')
plt.xlabel('False Positive Rate')
plt.show()
print('All Accuracy Scores in Cross: ' + str(scores))
print('Mean Accuracy Scores: ' + str(np.mean(scores)))
def example():
np.random.seed(1337) # for reproducibility
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.metrics.classification import accuracy_score
from dbn.tensorflow import SupervisedDBNClassification
# Loading dataset
digits = load_digits()
X, Y = digits.data, digits.target
# Data scaling
X = (X / 16).astype(np.float32)
# Splitting data
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.2,
random_state=0)
# Training
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=32,
activation_function='relu',
dropout_p=0.2)
print(X_train.shape, Y_train.shape)
classifier.fit(X_train, Y_train)
# Test
Y_pred = np.asarray(list(classifier.predict(X_test)))
print('Done.\nAccuracy: %f' % accuracy_score(Y_test, Y_pred))
def dbn():
estim = SupervisedDBNClassification(
hidden_layers_structure=[256, 256, 256, 256, 256, 256],
learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=10,
n_iter_backprop=100,
batch_size=32,
activation_function='relu',
dropout_p=0.2,
verbose=0)
estim.fit(x_train, y_train)
print("f1score", f1_score(estim.predict(x_test), y_test))
print("accuracy score", accuracy_score(estim.predict(x_test), y_test))
return 0
y = dataset.iloc[:, -1].values
from imblearn.over_sampling import SMOTE, ADASYN
X_resampled, y_resampled = ADASYN().fit_resample(X, y)
clf_smote = LinearSVC().fit(X_resampled, y_resampled)
X_resampled = X_resampled.astype(np.float32)
############### feature scaling
from sklearn.preprocessing import StandardScaler
X_resampled = StandardScaler().fit_transform(X_resampled)
# Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X_resampled,
y_resampled,
test_size=0.2,
random_state=0)
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=32,
activation_function='relu',
dropout_p=0.2)
classifier.fit(X_train, y_train)
import numpy as np
np.random.seed(1337) # for reproducibility
from sklearn.model_selection import train_test_split
from sklearn.metrics.classification import accuracy_score
from dbn.tensorflow import SupervisedDBNClassification
# use "from dbn import SupervisedDBNClassification" for computations on CPU with numpy
from sklearn.datasets import load_iris
iris = load_iris()
data_x = iris.data
data_y = iris.target
x_train, x_test, y_train, y_test = train_test_split(data_x, data_y, test_size=0.2, random_state=42)
# Training
classifier = SupervisedDBNClassification(hidden_layers_structure=[500, 1000, 500],
learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=20, # RBM training steps
n_iter_backprop=50, # ANN training steps
activation_function='relu',
dropout_p=0.2)
classifier.fit(x_train, y_train)
Confusion_matrix_plot('Logistic regression',
logistic_classifier.predict(X_test),
Y_test,
classes=['1', '2', '3', '4', 'R', 'W'],
cmap=plt.get_cmap('Blues'))
resultLR = logistic_classifier.predict(X_test)
#print(result)
#DBN ####################################################################3
classifier = SupervisedDBNClassification(hidden_layers_structure=[500, 500],
learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=10,
n_iter_backprop=100,
batch_size=32,
activation_function='relu',
dropout_p=0.2)
_ = classifier.fit(X_train, Y_train)
print(classification_report(Y_test, classifier.predict(X_test)))
Confusion_matrix_plot('DBN',
classifier.predict(X_test),
Y_test,
classes=['1', '2', '3', '4', 'R', 'W'],
cmap=plt.get_cmap('Blues'))
resultDBN = classifier.predict(X_test)
if __name__ == "__main__":
path = sys.argv[0]
path = path[:-(len(path) - path.rindex("/") - 1)]
#load config of the model
jsonfilename, jsonvariationfilename, classifiername, classificationfilename, classificationlevel, k, data_max = LoadConfig(
modelname)
#represent sequences of the test dataset as k-mer vector
testfilename = GetBase(testfastafilename)
matrixfilename = testfilename + "." + str(k) + ".matrix"
command = path + "fasta2matrix.py " + str(
k) + " " + testfastafilename + " " + matrixfilename
os.system(command)
testseqIDs, testinputs, testlabels, classes, nb_classes, input_length, level = loadData(
matrixfilename, data_max, classificationfilename, classificationlevel)
#load model
model = SupervisedDBNClassification.load(classifiername)
#predict labels for test dataset
pred_labels = model.predict(testinputs)
probas = model.predict_proba(testinputs)
#load classes with sequences
classeswithsequences = {}
variation = {}
testseqrecords = []
if minprobaforBlast <= 1.0:
testseqrecords = list(SeqIO.parse(testfastafilename, "fasta"))
#load classes
with open(jsonfilename) as json_file:
classeswithsequences = json.load(json_file)
#load variation
# if not os.path.exists(jsonvariationfilename):
# basename=modelname
print(puredata.describe().transpose())
X = puredata.drop('Survival-Time', axis=1)
y = puredata['Survival-Time']
X_train, X_test, y_train, y_test = train_test_split(X, y)
y_test = y_test.tolist()
scaler = StandardScaler()
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 = []
print('Loading in ' + files)
f = glob.glob(files)
full_Y = np.genfromtxt('converted_stage1_labels.csv', delimiter=',')
Y = full_Y[:, tz - 1]
X = np.empty([len(f), 62500])
for i in range(len(f)):
tmp = np.load(f[i])
tmp = np.reshape(tmp, [1, 62500])
X[i, :] = tmp
return X, Y
f = open(Model_Location + 'Output_Acc_Sum.txt', 'w')
for tz in range(0, 17):
print('\nChecking Accuracy of NN for zone {}'.format(tz + 1))
filename = Model_Location + 'Matt_Net_Zone_{}.pkl'.format(tz + 1)
print('Loading ' + filename)
My_Net = SupervisedDBNClassification.load(filename)
X, Y = get_dataset(tz + 1)
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.2,
random_state=0)
Yp = My_Net.predict(X_test)
score = accuracy_score(Y_test, Yp)
print('NN for Zone {} accuracy == {}'.format(tz + 1, score))
f.write('Zone, {}, accuracy, {}\n'.format(tz + 1, score))
f.close()
# im_arr = np.frombuffer(img_bytes, dtype=np.uint8)
# convert array into image
# img = cv2.imdecode(im_arr, flags=cv2.IMREAD_COLOR)
img = cv2.imread("img.jpg")
# convert BGR format to RGB format
rgb_image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# detect the (x,y)-coordinates of the bounding boxes
# corresponding to each face in the input image
# we are assuming the the boxes of faces are the SAME FACE or SAME PERSON
boxes = face_recognition.face_locations(rgb_image, model='hog')
# compute the facial embedding for the face
# creates a vector of 128 numbers representing the face
encodings = face_recognition.face_encodings(rgb_image, boxes)
# change into numpy array
encodings = np.array(encodings)
# replace value < 0 into 0 (replace negative value to zero)
encodings = encodings.clip(0)
if len(encodings > 0):
# load model
classifier = SupervisedDBNClassification.load('model.pkl')
# klasifikasi
pred = classifier.predict(encodings)
else:
pred = ['bukandosen']
# Hasil
output = f'{pred[0]}'
print(output)
sys.stdout.flush()
# Create the testing data (Positive Examples)
else:
if (os.stat(filename).st_size != 0):
X_Test = np.asarray([[word_to_index[w] for w in sent[:-1]] for sent in tokenized_sentences])
y_Test = np.transpose(np.asarray([1] * (len(list(sentences)))))
# Truncate and pad input sequences
X_Train = sequence.pad_sequences(X_Train, maxlen = max_review_length)
X_Test = sequence.pad_sequences(X_Test, maxlen = max_review_length)
# Training
classifier = SupervisedDBNClassification(hidden_layers_structure=[500,250,100],
learning_rate_rbm=0.1,
learning_rate=0.0001,
n_epochs_rbm=50,
n_iter_backprop=500,
batch_size=16,
activation_function='sigmoid',
dropout_p=0.25)
classifier.fit(X_Train, y_Train)
# Test
Y_pred = classifier.predict(X_Test)
Y_p = classifier.predict_proba(X_Test)
Y_n = classifier.predict_proba_dict(X_Test)
print(Y_n)
print(Y_p)
print(Y_p)
print(Y_pred)
print(y_Test)
print('Done.\nAccuracy: %f' % accuracy_score(y_Test, Y_pred))
# into feature vectors. The input to fit_transform should be a list of
# strings.
train_data_features = vectorizer.fit_transform(clean_train_LAPD)
test_data_features = vectorizer.transform(clean_test_LAPD)
# Numpy arrays are easy to work with, so convert the result to an
# array
np.asarray(train_data_features)
np.asarray(test_data_features)
# Training
classifier = SupervisedDBNClassification(
hidden_layers_structure=[500, 250, 100],
learning_rate_rbm=0.1,
learning_rate=0.0001,
n_epochs_rbm=50,
n_iter_backprop=500,
batch_size=16,
activation_function='sigmoid',
dropout_p=0)
classifier.fit(train_data_features.toarray(), train["Problematic"])
# Test
Y_pred = classifier.predict(test_data_features.toarray())
Y_p = classifier.predict_proba(test_data_features.toarray())
Y_n = classifier.predict_proba_dict(test_data_features.toarray())
print(Y_n)
print(Y_p)
print(Y_p)
print(Y_pred)
print(test["Problematic"])
def train(self, training_data, training_z):
"""Trains the classifier
Parameters:
-----------
training_data: numpy array, size Ngalaxes x Nbands
training data, each row is a galaxy, each column is a band as per
band defined above
training_z: numpy array, size Ngalaxies
true redshift for the training sample
"""
from dbn.tensorflow import SupervisedDBNClassification
self.training_z = training_z
# Create value-added data
print("Creating value-added training data")
self.training_data = get_valueadded_data(
training_data, self.bands, self.opt['errors'], self.opt['colors'],
self.opt['band_triplets'], self.opt['band_triplets_errors'],
self.opt['heal_undetected'], self.wants_arrays)
data_scaler = self.opt[
'data_scaler'] if 'data_scaler' in self.opt else 'MinMaxScaler'
n_bin = self.opt['bins']
train_percent = self.opt[
'train_percent'] if 'train_percent' in self.opt else 1
n_epochs_rbm = self.opt[
'n_epochs_rbm'] if 'n_epochs_rbm' in self.opt else 2
activation = self.opt[
'activation'] if 'activation' in self.opt else 'relu'
learning_rate_rbm = self.opt[
'learning_rate_rbm'] if 'learning_rate_rbm' in self.opt else 0.05
learning_rate = self.opt[
'learning_rate'] if 'learning_rate' in self.opt else 0.1
n_iter_backprop = self.opt[
'n_iter_backprop'] if 'n_iter_backprop' in self.opt else 25
batch_size = self.opt['batch_size'] if 'batch_size' in self.opt else 32
dropout_p = self.opt['dropout_p'] if 'dropout_p' in self.opt else 0.2
hidden_layers_structure = self.opt[
'hidden_layers_structure'] if 'hidden_layers_structure' in self.opt else [
256, 256
]
print("Finding bins for training data")
# Data rescaling
self.scaler = getattr(preprocessing, data_scaler)()
print(f"Using {data_scaler} to rescale data for better results")
# Fit scaler on data and use the same scaler in the future when needed
self.scaler.fit(self.training_data)
# apply transform to get rescaled values
self.training_data = self.scaler.transform(
self.training_data
) # inverse: data_original = scaler.inverse_transform(data_rescaled)
# Now put the training data into redshift bins.
# Use zero so that the one object with minimum
# z in the whole survey will be in the lowest bin
training_bin = np.zeros(self.training_z.size)
# Find the edges that split the redshifts into n_z bins of
# equal number counts in each
p = np.linspace(0, 100, n_bin + 1)
z_edges = np.percentile(self.training_z, p)
# Now find all the objects in each of these bins
for i in range(n_bin):
z_low = z_edges[i]
z_high = z_edges[i + 1]
training_bin[(self.training_z > z_low)
& (self.training_z < z_high)] = i
if 0 < train_percent < 100:
# for speed, cut down to ?% of original size
print(
f'Cutting down to {train_percent}% of original training sample size for speed.'
)
cut = np.random.uniform(0, 1,
self.training_z.size) < train_percent / 100
training_bin = training_bin[cut]
self.training_data = self.training_data[cut]
elif train_percent == 100:
pass
else:
raise ValueError('train_percent is not valid')
print('Setting up the layers for DBN')
# Set up the layers
classifier = SupervisedDBNClassification(
hidden_layers_structure=hidden_layers_structure,
learning_rate_rbm=learning_rate_rbm,
learning_rate=learning_rate,
n_epochs_rbm=n_epochs_rbm,
n_iter_backprop=n_iter_backprop,
batch_size=batch_size,
activation_function=activation,
dropout_p=dropout_p)
# Train the model
print("Fitting classifier")
classifier.fit(self.training_data, training_bin)
self.classifier = classifier
self.z_edges = z_edges
if __name__ == '__main__':
# Load and normalize the dataset
kddcup = fetch_kddcup99(subset='smtp', shuffle=True, random_state=1000)
ss = StandardScaler()
X = ss.fit_transform(kddcup['data']).astype(np.float32)
le = LabelEncoder()
Y = le.fit_transform(kddcup['target']).astype(np.float32)
# Create train and test sets
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.25, random_state=1000)
# Train the model
classifier = SupervisedDBNClassification(hidden_layers_structure=[64, 64],
learning_rate_rbm=0.001,
learning_rate=0.01,
n_epochs_rbm=20,
n_iter_backprop=150,
batch_size=256,
activation_function='relu',
dropout_p=0.25)
classifier.fit(X_train, Y_train)
Y_pred = classifier.predict(X_test)
print('Accuracy score: {}'.format(accuracy_score(Y_test, Y_pred)))
x_train = np.asarray(X)[train]
y_train = np.asarray(Y)[train]
x_test = np.asarray(X)[test]
y_test = np.asarray(Y)[test]
mdl+=1
print("Ukuran data model ",mdl)
print("Ukuran x_train : ",x_train.shape)
print("Ukuran y_train",y_train.shape)
print("Ukuran x_test : ",x_test.shape)
print("Ukuran y_test",y_test.shape)
classifier = SupervisedDBNClassification(hidden_layers_structure=[len(np.asarray(X)[train]),len(np.asarray(Y)[train])],
learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=10,
n_iter_backprop=100,
batch_size=32,
activation_function='relu',
dropout_p=0.2)
tr_loss=classifier.fit(np.asarray(X)[train], np.asarray(Y)[train])
val_loss = classifier.fit(np.asarray(X)[test], np.asarray(Y)[test])
train_loss.append(tr_loss)
validation_loss.append(val_loss)
predict_train = classifier.predict(np.asarray(X)[train])
accuracy_train = accuracy_score(np.asarray(Y)[train], predict_train)
acc_train.append(accuracy_train)
pred_train.append(predict_train)
predict_test = classifier.predict(np.asarray(X)[test])
pred_test.append(predict_test)
accuracy_test = accuracy_score(np.asarray(Y)[test], predict_test)
acc_test.append(accuracy_test)
def image_subset(index, x, y):
xs = []
ys = []
for i in range(len(x)):
if y[i] < index:
xs.append(x[i])
ys.append(y[i])
return np.array(xs), np.array(ys)
dbn = SupervisedDBNClassification(hidden_layers_structure=[1024, 512, 256],
learning_rate_rbm=learning_rate_rbm,
learning_rate=learning_rate,
n_epochs_rbm=n_epochs_rbm,
n_iter_backprop=n_iter_backprop,
batch_size=batch_size,
activation_function='sigmoid',
dropout_p=0.2)
(cx_train, cy_train), (cx_test, cy_test) = cifar10.load_data()
cx_train, cy_train = image_subset(num_classes, cx_train, cy_train)
cx_test, cy_test = image_subset(num_classes, cx_test, cy_test)
if use_all:
train_ex = len(cx_train)
test_ex = len(cx_test)
print('Using {} training and {} testing'.format(train_ex, test_ex))
if use_color:
from sklearn.cross_validation import train_test_split
from sklearn.metrics.classification import accuracy_score
from dbn.tensorflow import SupervisedDBNClassification
# Loading dataset
digits = load_digits()
X, Y = digits.data, digits.target
# Data scaling
X = (X / 16).astype(np.float32)
# Splitting data
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=0)
# Training
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=32,
activation_function='relu',
dropout_p=0.2)
classifier.fit(X_train, Y_train)
# Test
Y_pred = classifier.predict(X_test)
print 'Done.\nAccuracy: %f' % accuracy_score(Y_test, Y_pred)
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))
min_max_scaler = MinMaxScaler()
X = min_max_scaler.fit_transform(X)
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))
else:
if (os.stat(filename).st_size != 0):
X_Test = np.asarray([[word_to_index[w] for w in sent[:-1]]
for sent in tokenized_sentences])
y_Test = np.transpose(np.asarray([1] * (len(list(sentences)))))
# Truncate and pad input sequences
X_Train = sequence.pad_sequences(X_Train, maxlen=max_review_length)
X_Test = sequence.pad_sequences(X_Test, maxlen=max_review_length)
# Training
classifier = SupervisedDBNClassification(
hidden_layers_structure=list(
map(int, FLAGS.hidden_layers_structure.split(","))),
learning_rate_rbm=FLAGS.learning_rate_rbm,
learning_rate=FLAGS.learning_rate,
n_epochs_rbm=FLAGS.n_epochs_rbm,
n_iter_backprop=FLAGS.n_iter_backprop,
batch_size=FLAGS.batch_size,
activation_function=FLAGS.activation_function,
dropout_p=FLAGS.dropout_p)
classifier.fit(X_Train, y_Train)
# Test
Y_pred = classifier.predict(X_Test)
Y_p = classifier.predict_proba(X_Test)
Y_n = classifier.predict_proba_dict(X_Test)
print(Y_n)
print(Y_p)
print(Y_p)
print(Y_pred)
print('y_train', y_train.shape)
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))
import numpy as np
np.random.seed(1337) # for reproducibility
from sklearn.model_selection import train_test_split
from sklearn.metrics.classification import accuracy_score
from dbn.tensorflow import SupervisedDBNClassification
# use "from dbn import SupervisedDBNClassification" for computations on CPU with numpy
from sklearn.datasets import load_iris
iris = load_iris()
data_x = iris.data
data_y = iris.target
x_train, x_test, y_train, y_test = train_test_split(data_x,
data_y,
test_size=0.2,
random_state=42)
# Training
classifier = SupervisedDBNClassification(
hidden_layers_structure=[500, 1000, 500],
learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=20, # RBM training steps
n_iter_backprop=50, # ANN training steps
activation_function='relu',
dropout_p=0.2)
classifier.fit(x_train, y_train)
# learning_rate_rbm=0.05, # learning rate para RBM pretraining
# learning_rate=0.1, # Learning rate para el backpropagation de los nodos
# n_epochs_rbm=10, # Epochs para RBM pretraining (n epochs x capa)
# n_iter_backprop=100, # Packpropagation iterations
# batch_size=46, # Tamaño de batch
# activation_function='sigmoid', # Función de activación
# dropout_p=0.1) # Dropout de nodos para evitar overfitting
# classifier.fit(X_train, y_train) # Entrenamiento del modelo según datos procesados en 3.2.2
#%% [markdown]
# ##### 3.2.4 Obtención de resultados con modelo ya entrenado
#%%
# En primer lugar, cargamos los datos
tclassifier = DBNC.load('model.pkl')
# Datos trained classifier
tclassifier, tclassifier.unsupervised_dbn.hidden_layers_structure
#%%
# Predicción de test
y_pred = tclassifier.predict(X_test)
#%%
# Análisis de resultados
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
y_train = y_train.flatten()
y_test = y_test.flatten()
time_load_end = time.clock()
print("Loading finished, loading time: %g seconds" %
(time_load_end - time_load_start))
X_test_even, y_test_even = fipr.load_csv("test_file_even.csv", True)
y_test_even = y_test_even.flatten()
# Build DBN classifier
classifier = SupervisedDBNClassification(hidden_layers_structure=[20, 20],
learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=10,
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))
'''
labels[i] = output[i]
print "Begin DBN model"
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.1,
random_state=i)
dbn_model = DBN([X_train.shape[1], 300, 2],
learn_rates=0.3,
learn_rate_decays=0.9,
epochs=100,
verbose=1)
dbn_model.fit(X_train, Y_train)
y_true, y_pred = Y_test, dbn_model.predict(X_test) # Get our predictions
print(classification_report(y_true, y_pred)) # Classification on each digit
print 'The accuracy is:', accuracy_score(y_true, y_pred)
print "Begin DBN V2 model"
classifier = SupervisedDBNClassification(hidden_layers_structure=[1000, 200],
learning_rate_rbm=0.05,
learning_rate=0.1,
n_epochs_rbm=10,
n_iter_backprop=100,
batch_size=32,
activation_function='relu',
dropout_p=0.2)
classifier.fit(X_train, Y_train[:, 0])
# Test
Y_pred = classifier.predict(X_test)
print 'Done.\nAccuracy: %f' % accuracy_score(Y_test, Y_pred)
test_pos = generateDatasets(filename, "positive")
for i in xrange(0, len(test_pos["LAPD"])):
clean_test_LAPD.append(" ".join(
KaggleWord2VecUtility.review_to_wordlist(
test_pos["LAPD"][i], False)))
########################################################################################################
# GENERATE MODEL
########################################################################################################
# Training
classifier = SupervisedDBNClassification(
hidden_layers_structure=hidden_layers_units,
learning_rate_rbm=learning_rate_rbm,
learning_rate=learning_rate_backprop,
n_epochs_rbm=n_epochs_rbm,
n_iter_backprop=n_iter_backprop,
batch_size=batch_size,
activation_function=activation_function,
dropout_p=dropout_p)
########################################################################################################
# GENERATE WORD EMBEDDING
########################################################################################################
# Use word embeddings
if word_embedding == 'True':
if w2v_dictionary != "None":
# Load w2v model
print "Loading w2v model..."
model = Word2Vec.load(w2v_dictionary)
originally downloaded from https://github.com/albertbup/deep-belief-network
on March 29, 2017, and modified slightly to support python3. The
DBN folder is covered under the MIT license.
"""
from __future__ import print_function
from __future__ import division
from dbn.tensorflow import SupervisedDBNClassification
from sklearn.preprocessing import OneHotEncoder
from sklearn.metrics import accuracy_score
from tensorflow.examples.tutorials.mnist import input_data
import numpy as np
train_ex = 8000
dbn = SupervisedDBNClassification(hidden_layers_structure=[1024, 1024],
learning_rate_rbm=0.1,
learning_rate=0.1,
n_epochs_rbm=10,
n_iter_backprop=100,
batch_size=100,
activation_function='sigmoid',
dropout_p=0.2)
def unpickle(file):
"""Load data"""
import pickle
with open(file, 'rb') as source:
ret_dict = pickle.load(source, encoding='bytes')
return ret_dict
def get_data():
"""
setting = read_setting(open('setting.txt'))
file_out = open('../result/dbn.log', 'a')
X_train = np.loadtxt('../data/train_dataset_new.txt')
X_test = np.loadtxt('../data/test_dataset_new.txt')
Y_train = np.array([np.argmax(row) for row in np.loadtxt('../data/train_labels_new.txt')])
Y_test = np.array([np.argmax(row) for row in np.loadtxt('../data/test_labels_new.txt')])
# Training
classifier = SupervisedDBNClassification(hidden_layers_structure=setting['hidden_layers_structure'],
learning_rate_rbm=float(setting['learning_rate_rbm']),
learning_rate=float(setting['learning_rate']),
n_epochs_rbm=int(setting['n_epochs_rbm']),
n_iter_backprop=int(setting['n_iter_backprop']),
batch_size=int(setting['batch_size']),
activation_function=setting['activation_function'],
dropout_p=float(setting['dropout_p']),
l2_regularization=float(setting['l2_regularization']),
contrastive_divergence_iter=int(setting['contrastive_divergence_iter']))
classifier.fit(X_train, Y_train)
# Test
Y_pred = classifier.predict(X_train)
accuracy = accuracy_score(Y_train, Y_pred)
print('Done.\nAccuracy: %f' % accuracy)
file_out.write('\n\n-------------------------------\n\n')
for line in open('setting.txt'):
