def test_fit():
X = Xdigits.copy()
rbm = BernoulliRBM(n_components=64,
learning_rate=0.1,
batch_size=10,
n_iter=7,
random_state=9)
rbm.fit(X)
assert_almost_equal(rbm.score_samples(X).mean(), -21., decimal=0)
# in-place tricks shouldn't have modified X
assert_array_equal(X, Xdigits)
def test_fit_gibbs_sparse():
# Gibbs on the RBM hidden layer should be able to recreate [[0], [1]] from
# the same input even when the input is sparse, and test against non-sparse
rbm1 = test_fit_gibbs()
rng = np.random.RandomState(42)
from scipy.sparse import csc_matrix
X = csc_matrix([[0.], [1.]])
rbm2 = BernoulliRBM(n_components=2, batch_size=2,
n_iter=42, random_state=rng)
rbm2.fit(X)
assert_almost_equal(rbm2.components_,
np.array([[0.02649814], [0.02009084]]), decimal=4)
assert_almost_equal(rbm2.gibbs(X), X.toarray())
assert_almost_equal(rbm1.components_, rbm2.components_)
def test_partial_fit():
X = Xdigits.copy()
rbm = BernoulliRBM(n_components=64, learning_rate=0.1,
batch_size=20, random_state=9)
n_samples = X.shape[0]
n_batches = int(np.ceil(float(n_samples) / rbm.batch_size))
batch_slices = np.array_split(X, n_batches)
for i in range(7):
for batch in batch_slices:
rbm.partial_fit(batch)
assert_almost_equal(rbm.score_samples(X).mean(), -21., decimal=0)
assert_array_equal(X, Xdigits)
def test_fit_gibbs():
"""
Gibbs on the RBM hidden layer should be able to recreate [[0], [1]]
from the same input
"""
rng = np.random.RandomState(42)
X = np.array([[0.], [1.]])
rbm1 = BernoulliRBM(n_components=2, batch_size=2,
n_iter=42, random_state=rng)
# you need that much iters
rbm1.fit(X)
assert_almost_equal(rbm1.components_,
np.array([[0.02649814], [0.02009084]]), decimal=4)
assert_almost_equal(rbm1.gibbs(X), X)
return rbm1
def temp(features):
[featuresNorm, MAX, MIN] = normalizeFeatures(features)
[X, Y] = listOfFeatures2Matrix(featuresNorm)
rbm = BernoulliRBM(n_components = 10, n_iter = 1000, learning_rate = 0.01, verbose = False)
X1 = X[0::2]
X2 = X[1::2]
Y1 = Y[0::2]
Y2 = Y[1::2]
rbm.fit(X1,Y1)
YY = rbm.transform(X1)
for i in range(10):plt.plot(YY[i,:],'r')
for i in range(10):plt.plot(YY[i+10,:],'g')
for i in range(10):plt.plot(YY[i+20,:],'b')
plt.show()
def __init__(self,
n_components=256,
batch_size=100,
lr=0.01,
patience=3,
epochs=1000,
verbose=0):
self.rbm = BernoulliRBM(n_components=n_components,
n_iter=1,
batch_size=batch_size,
learning_rate=lr,
verbose=verbose)
self.patience = patience
self.epochs = epochs
self.verbose = verbose
def update_feat_with_RBMs(s_data, greedy_pre_train=1):
data = scale(s_data.get_data())
print(np.min(data))
print(np.max(data))
# Fit and Transform data
for i in range(greedy_pre_train):
# Initialize the RBM
rbm = BernoulliRBM(n_components=90,
n_iter=50,
learning_rate=0.01,
verbose=True)
rbm.fit(data)
s_data.update_features(rbm.transform)
data = s_data.get_data()
def _RBM(self, X, y):
from sklearn.neural_network import BernoulliRBM
# PCA model creation, number of components
# feature extraction method. Used here (after sampling) because we are
# creating an universal model and not this_dataset-specific.
neural_network = BernoulliRBM(n_components=self.k_features)
neural_network.fit(X, y)
X = neural_network.transform(X)
self.feature_reduction_method = neural_network
return X
def deep_belief_network():
"""Train a two layer deep belief network."""
digits = load_digits()
X, y = digits.data, digits.target
X_train, X_test, y_train, y_test = train_test_split(X,
y,
train_size=0.7,
random_state=0)
rbm1 = BernoulliRBM(n_components=144, n_iter=50, learning_rate=0.06)
rbm2 = BernoulliRBM(n_components=100, n_iter=50, learning_rate=0.06)
logistic = LogisticRegression(C=6000)
scaler = MinMaxScaler()
pipeline = Pipeline([('scaler', scaler), ('rbm1', rbm1), ('rbm2', rbm2),
('logistic', logistic)])
pipeline.fit(X_train, y_train)
print 'Score on train set =', pipeline.score(X_train, y_train)
print 'Score on test set =', pipeline.score(X_test, y_test)
plot_rbm_weights(rbm1)
plot_rbm_weights(rbm2, shape=(12, 12))
return pipeline
def neural_net():
digits = datasets.load_digits()
X = np.asarray(digits.data, 'float32')
sidelength = int(np.sqrt(X.shape[1]))
X, Y = nudge_dataset(X, digits.target, dimen=(sidelength, sidelength))
#Scale the data to be between zero and 1 at all pixels:
X = (X - np.min(X, axis=0)) / (np.max(X, axis=0) + 0.0001)
#Split the data set into a training and testing set:
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.2,
random_state=0)
#Models we will use
logistic = linear_model.LogisticRegression()
rbm = BernoulliRBM(random_state=0, verbose=True)
#The classifier
classifier = Pipeline(steps=[('rbm', rbm), ('logistic', logistic)])
###############################################################################
# Training
# Hyper-parameters. These were set by cross-validation,
# using a GridSearchCV. Here we are not performing cross-validation to
# save time.
rbm.learning_rate = 0.06
rbm.n_iter = 20
# More components tend to give better prediction performance, but larger
# fitting time
rbm.n_components = 100
logistic.C = 6000.0
# Training RBM-Logistic Pipeline
classifier.fit(X_train, Y_train)
# Training Logistic regression
#logistic_classifier = linear_model.LogisticRegression(C=100.0)
#logistic_classifier.fit(X_train, Y_train)
###############################################################################
# Evaluation
print ""
print("Logistic regression using RBM features:\n%s\n" %
(metrics.classification_report(Y_test, classifier.predict(X_test))))
#Predict a few individual cases:
print classifier.predict(X_test[:5, :]), Y_test[:5]
def pretraining(self):
input_layer = self.x_train
for i in range(len(self.hidden_layer)):
print("DBN Layer {0} Pre-training".format(i + 1))
rbm = BernoulliRBM(n_components=self.hidden_layer[i],
learning_rate=self.learning_rate_rbm,
batch_size=self.batch_size_rbm,
n_iter=self.n_epochs_rbm,
verbose=self.verbose_rbm,
random_state=self.verbose_rbm)
rbm.fit(input_layer)
# size of weight matrix is [input_layer, hidden_layer]
self.weight_rbm.append(rbm.components_.T)
self.bias_rbm.append(rbm.intercept_hidden_)
input_layer = rbm.transform(input_layer)
print('Pre-training finish.')
def rbm_mlp(trainX, trainY):
rbm = BernoulliRBM(n_components=200,
n_iter=20,
learning_rate=0.001,
verbose=True)
mlp = MLPClassifier(hidden_layer_sizes=(50, ),
max_iter=10000,
alpha=1e-4,
solver='sgd',
verbose=True,
tol=1e-4,
random_state=1,
learning_rate_init=.001)
classifier = Pipeline([("rbm", rbm), ("mlp", mlp)])
classifier.fit(trainX, trainY)
return classifier
def train(cls) -> str:
"""
Returns classification results
"""
X_train, X_test, Y_train, Y_test = RestrictedBoltzmann.load_data()
logistic = linear_model.LogisticRegression(solver='newton-cg', tol=1)
rbm = BernoulliRBM(random_state=0, verbose=True)
rbm_features_classifier = Pipeline(steps=[('rbm',
rbm), ('logistic',
logistic)])
# Hyper-parameters. These were set by cross-validation,
# using a GridSearchCV. Here we are not performing cross-validation to
# save time.
rbm.learning_rate = 0.06
rbm.n_iter = 10
# More components tend to give better prediction performance, but larger
# fitting time
rbm.n_components = 100
logistic.C = 6000
# Training RBM-Logistic Pipeline
rbm_features_classifier.fit(X_train, Y_train)
# Training the Logistic regression classifier directly on the pixel
raw_pixel_classifier = clone(logistic)
raw_pixel_classifier.C = 100.
raw_pixel_classifier.fit(X_train, Y_train)
RestrictedBoltzmann.store_model("rbm_features",
rbm_features_classifier)
RestrictedBoltzmann.store_model("raw_pixel", raw_pixel_classifier)
# Evaluation
Y_pred = rbm_features_classifier.predict(X_test)
report1 = "Logistic regression using RBM features:\n%s\n" % (
metrics.classification_report(Y_test, Y_pred))
Y_pred = raw_pixel_classifier.predict(X_test)
report2 = "Logistic regression using raw pixel features:\n%s\n" % (
metrics.classification_report(Y_test, Y_pred))
return f"{report1} \n\n {report2}"
def train_ca_cd(type, X_train, y_train, X_test, y_test):
input_layer = X_train
hidden_layer = [250, 500, 200]
weight_rbm = []
bias_rbm = []
for i in range(len(hidden_layer)):
print("DBN Layer {0} Pre-training".format(i + 1))
rbm = BernoulliRBM(n_components=hidden_layer[i],
learning_rate=0.0005,
batch_size=512,
n_iter=200,
verbose=2,
random_state=1)
rbm.fit(input_layer)
# size of weight matrix is [input_layer, hidden_layer]
weight_rbm.append(rbm.components_.T)
bias_rbm.append(rbm.intercept_hidden_)
input_layer = rbm.transform(input_layer)
print('Pre-training finish.', np.shape(weight_rbm[0]),
np.shape(bias_rbm[0]))
test_rms = 0
result = []
model = Sequential()
print('Fine-tuning start.')
for i in range(0, len(hidden_layer)):
print('i:', i)
if i == 0:
model.add(
Dense(hidden_layer[i],
activation='sigmoid',
input_dim=np.shape(X_train)[1]))
elif i >= 1:
model.add(Dense(hidden_layer[i], activation='sigmoid'))
else:
pass
layer = model.layers[i]
layer.set_weights([weight_rbm[i], bias_rbm[i]])
# model.add(Dense(np.shape(yTrain)[1], activation='linear'))
model.add(
Dense(1, activation='linear',
kernel_regularizer=regularizers.l2(0.01)))
# sgd = SGD(lr=0.005, decay=0)
model.compile(loss='mse', optimizer="rmsprop") # sgd
model.fit(X_train, y_train, batch_size=150, epochs=100, verbose=5)
model.save('../model/dwt_dbn_' + type + '_100.h5')
print('Fine-tuning finish.')
return model
def update_model(self, image_path, label_file, train_size):
if not os.path.isdir(self.model_path):
os.mkdir(self.model_path)
if not os.path.isdir(image_path):
exit(1)
image_label_pair = pd.read_csv(label_file, encoding="utf-8")
image_label_pair = image_label_pair[:train_size]
index = 0
x = []
y = []
y_count = 0
start = datetime.datetime.now()
start_time = datetime.datetime.now()
for i in range(len(image_label_pair)):
image = image_path + "/" + str(image_label_pair.iloc[i]["name"])
labels = image_label_pair.iloc[i]["value"]
if type(labels) == int:
labels = str(labels)
for l in range(self.image_label_count):
y.append(self.label_list.index(labels[l]))
y_count += 1
if index == 0:
x = self.__convertPoint__(image)
else:
x = np.append(x, self.__convertPoint__(image), axis=0)
# print len(y), len(x)
index += 1
end_time = datetime.datetime.now()
if i in range(0, len(image_label_pair),
len(image_label_pair) / 20):
print u"数据集已完成:", round(
float(i) / len(image_label_pair),
4) * 100, "%", u"所用时间:", end_time - start_time
start_time = datetime.datetime.now()
print u"数据集已生成 共用时", datetime.datetime.now() - start, u"开始建模"
rbm = BernoulliRBM(random_state=0,
verbose=True,
learning_rate=0.02,
n_iter=400,
n_components=650,
batch_size=12)
svm = SVC(kernel="linear", tol=5e-14, class_weight="balanced")
classifier = Pipeline(steps=[("rbm", rbm), ("svm", svm)])
model = classifier.fit(x, y)
joblib.dump(model, self.model_file)
return True
def estimate_n_components():
X = load_data('gender/male')
X = X.astype(np.float32) / 256
n_comp_list = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1100, 1200]
scores = []
for n_comps in n_comp_list:
rbm = BernoulliRBM(random_state=0, verbose=True)
rbm.learning_rate = 0.06
rbm.n_iter = 50
rbm.n_components = 100
rbm.fit(X)
score = rbm.score_samples(X).mean()
scores.append(score)
plt.figure()
plt.plot(n_comp_list, scores)
plt.show()
return n_comp_list, scores
def update_feat_with_DBN(s_data, output=400, rbm_num=2):
# out_dims = np.arange(100, output + 100, int(output/rbm_num))
out_dims = [60, 30]
print(out_dims)
data = scale(s_data.get_data())
print(np.min(data))
print(np.max(data))
for i in range(rbm_num):
# Initialize the RBM
rbm = BernoulliRBM(n_components=out_dims[i],
n_iter=50,
learning_rate=0.01,
verbose=True)
rbm.fit(data)
s_data.update_features(rbm.transform)
data = s_data.get_data()
def build_model_rbm():
np.random.seed(12)
rbm_estimators = list()
# rbm = BernoulliRBM(random_state=12, verbose=0, n_components=in_dim)
rbm = BernoulliRBM(random_state=np.random.randint(1, 100), verbose=0)
lr = LogisticRegression()
rbm.learning_rate = 0.0001
# rbm.n_iter = 20
# rbm.n_components = 50
lr.C = 10.0
rbm_estimators.append(('rbm', rbm))
rbm_estimators.append(('lr', lr))
return rbm_estimators
def test_sparse_and_verbose():
# Make sure RBM works with sparse input when verbose=True
old_stdout = sys.stdout
sys.stdout = StringIO()
from scipy.sparse import csc_matrix
X = csc_matrix([[0.], [1.]])
rbm = BernoulliRBM(n_components=2, batch_size=2, n_iter=1,
random_state=42, verbose=True)
try:
rbm.fit(X)
s = sys.stdout.getvalue()
# make sure output is sound
assert re.match(r"\[BernoulliRBM\] Iteration 1,"
r" pseudo-likelihood = -?(\d)+(\.\d+)?,"
r" time = (\d|\.)+s", s)
finally:
sys.stdout = old_stdout
def br(X_train, y_train, X_test, ln=0.0001, ni=30, C=1, gamma=0.1):
from sklearn.neural_network import BernoulliRBM
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC
linear = SVC(kernel='linear',
C=C,
degree=gamma,
class_weight='balanced',
probability=True)
rbm = BernoulliRBM(n_components=50,
learning_rate=ln,
n_iter=ni,
verbose=True)
classifier = Pipeline(steps=[('rbm', rbm), ('linear', linear)])
classifier.fit(X_train, y_train)
y_predict = classifier.predict(X_test)
return y_predict
def SGD():
SGD = linear_model.SGDClassifier(loss='hinge',
penalty='l2',
random_state=42,
n_jobs=-1,
epsilon=0.001)
rbm = BernoulliRBM(random_state=0, verbose=True)
classifier = Pipeline(steps=[('rbm', rbm), ('SGD', SGD)])
# RBM parameters obtained after cross-validation
rbm.learning_rate = 0.01
rbm.n_iter = 15
rbm.n_components = 50
SGD.alpha = 0.0001
SGD.C = 1
# Training SGD
SGD_classifier = linear_model.SGDClassifier(loss='hinge',
penalty='l2',
random_state=42,
n_jobs=-1,
alpha=0.0001,
epsilon=0.001)
SGD_classifier.fit(data_train, target_train)
# Training RBM-SGD Pipeline
classifier.fit(data_train, target_train)
print("printing_results")
print("SGD using RBM features:\n%s\n" % (metrics.classification_report(
target_test, classifier.predict(data_test))))
cm = confusion_matrix(target_test, classifier.predict(data_test))
plt.matshow(cm)
plt.title('Confusion Matrix SVM with SDG with RBM Features')
plt.colorbar()
plt.ylabel('True Label')
plt.xlabel('Predicted Label')
plt.savefig('confusion_matrix1.jpg')
print("SGD using raw pixel features:\n%s\n" %
(metrics.classification_report(target_test,
SGD_classifier.predict(data_test))))
cm1 = confusion_matrix(target_test, SGD_classifier.predict(data_test))
plt.matshow(cm1)
plt.title('Confusion Matrix SVM with SDG Raw Features')
plt.colorbar()
plt.ylabel('True Label')
plt.xlabel('Predicted Label')
plt.savefig('confusion_matrix2.jpg')
def pretrain(self, save=True):
visual_layer = self.data
for i in range(len(self.hidden_sizes)):
print("[DBN] Layer {} Pre-Training".format(i + 1))
rbm = BernoulliRBM(n_components=self.hidden_sizes[i],
n_iter=self.rbm_iters[i],
learning_rate=self.rbm_learning_rate[i],
verbose=True,
batch_size=128)
rbm.fit(visual_layer)
self.rbm_weights.append(rbm.components_)
self.rbm_biases.append(rbm.intercept_hidden_)
self.rbm_h_act.append(rbm.transform(visual_layer))
visual_layer = self.rbm_h_act[-1]
def trainRBM_SVM(features, Cparam, nComponents):
[X, Y] = listOfFeatures2Matrix(features)
rbm = BernoulliRBM(n_components = nComponents, n_iter = 30, learning_rate = 0.2, verbose = True)
rbm.fit(X,Y)
newX = rbm.transform(X)
# colors = ["r","g","b"]
# for i in range(1,Y.shape[0],5):
# plt.plot(newX[i,:], colors[int(Y[i])])
# plt.show()
classifier = {}
classifier["rbm"] = rbm
svm = sklearn.svm.SVC(C = Cparam, kernel = 'linear', probability = True)
svm.fit(newX,Y)
classifier["svm"] = svm
return classifier
def build_model(self, captcha_type=None):
captcha_type = self.load_img(captcha_type)
x = self.pixes_data
y = self.pixes_lable
print u'开始建模。。。'
rbm = BernoulliRBM(random_state=0,
verbose=True,
learning_rate=0.02,
n_iter=400,
n_components=650,
batch_size=12)
svm = SVC(kernel="linear", tol=5e-14, class_weight="balanced")
classifier = Pipeline(steps=[("rbm", rbm), ("svm", svm)])
self.model = classifier.fit(x, y)
if captcha_type == 'number':
joblib.dump(self.model, self.number_model_file)
else:
joblib.dump(self.model, self.symbol_model_file)
def RBM_new():
'''
RBM to evaluate on artificially generated data
'''
#Define datasize
(val_length, test_length) = (11710, 105384)
(train_half_length, test_half_length) = (int(val_length/2), int(test_length/2))
#Generate artificial Z
print('\n##############VALIDATION DATA#################')
(TL_val, Z_val) = Z_new_generator(val_length, classifier_stats_val)
print('\n##############TEST DATA#################')
(TL_test, Z_test) = Z_new_generator(test_length, classifier_stats_test)
#Convert '-1's to '0'
Z_val[Z_val==-1]=0
Z_test[Z_test==-1]=0
#Train RBM
rbm = BernoulliRBM(n_components = N_COMPONENTS, n_iter=N_ITERATIONS, learning_rate=LEARNING_RATE, batch_size=BATCH_SIZE)
print(f'\nStarting RBM training.... {datetime.datetime.now().time()}')
Z_val_probability = rbm.fit_transform(Z_val)
Z_test_probability = rbm.transform(Z_test)
print(f'\nRBM complete.... - {datetime.datetime.now().time()}')
#Convert probability to values
Z_val_final = np.sign(Z_val_probability - T1)
Z_test_final = np.sign(Z_test_probability - T1)
#RBM on validation data
print(f'\n\n****VALIDATION RBM RESULTS*****')
true_positives = sum(Z_val_final[train_half_length:]==-1)
false_negatives = sum(Z_val_final[train_half_length:]==1)
false_positives = sum(Z_val_final[0:train_half_length]==-1)
true_negatives = sum(Z_val_final[0:train_half_length]==1)
MLmodel_evaluation(true_positives, false_positives, false_negatives, true_negatives)
#RBM on test data
print(f'\n\n****TEST RBM RESULTS*****')
true_positives = sum(Z_test_final[test_half_length:]==-1)
false_negatives = sum(Z_test_final[test_half_length:]==1)
false_positives = sum(Z_test_final[0:test_half_length]==-1)
true_negatives = sum(Z_test_final[0:test_half_length]==1)
MLmodel_evaluation(true_positives, false_positives, false_negatives, true_negatives)
def Train():
"""
Train Function
"""
if os.path.exists('X_train.pkl') == False:
print("generate data and split to train test set.")
with open('X.pkl') as Xf:
X = cPickle.load(Xf)
with open('Y.pkl') as Yf:
Y = cPickle.load(Yf)
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=0)
print("load data from pickled files..")
with open('X_train.pkl') as x_train_f:
X_train = cPickle.load(x_train_f)
with open('X_test.pkl') as x_test_f:
X_test = cPickle.load(x_test_f)
with open('Y_train.pkl') as y_train_f:
Y_train = cPickle.load(y_train_f)
with open('Y_test.pkl') as y_test_f:
Y_test = cPickle.load(y_test_f)
print("Load Data success!")
logistic = linear_model.LogisticRegression()
rbm = BernoulliRBM(random_state=0, verbose=True)
rbm.learning_rate = 0.06
rbm.n_iter = 300
rbm.n_components = 1000
logistic.C = 6000.0
clf = Pipeline(steps=[('rbm', rbm), ('logistic', logistic)])
clf.fit(X_train,Y_train)
#logistic_classifier = linear_model.LogisticRegression(C=100.0)
#logistic_classifier.fit(X_train, Y_train)
#print("Logistic regression using raw pixel features:\n%s\n" % (
#metrics.classification_report(
# Y_test,
# logistic_classifier.predict(X_test))))
print("fit complete..")
print("Logistic regression using RBM features:\n%s\n" % (
metrics.classification_report(
Y_test,
clf.predict(X_test))))
with open('clf.pkl','a+') as clf_f:
cPickle.dump(clf,clf_f)
def run():
train= trainingImage()
trainTarget = trainingImageTarget()
rbm = BernoulliRBM(n_components=numComponents, learning_rate=eta, batch_size=numBatch ,random_state=0, verbose= True)
errors = np.empty(numEpochs)
for epoch in range(numEpochs):
transformedTrain = rbm.fit_transform(train, trainTarget)
reconstructedTrain = transformedTrain.dot(rbm.components_)
errors[epoch] = np.sum(np.abs(reconstructedTrain - train))
digts , digitAxis = plt.subplots(2, len(classes))
for index in range(len(classes)):
imageIndex = classes[index]
original = np.copy(train[imageIndex].reshape(28,28))
reconstructed= np.copy(reconstructedTrain[imageIndex].reshape(28,28))
digitAxis[0, index].imshow(original, extent=(0, 28, 0, 28) , aspect = 'auto')
digitAxis[1, index].imshow(reconstructed, extent=(0, 28, 0, 28) , aspect = 'auto' )
plt.show()
def rbmGS(self):
rbm = BernoulliRBM()
logistic = linear_model.LogisticRegression()
classifier = Pipeline([("rbm", rbm), ("logistic", logistic)])
print ("SEARCHING RBM + LOGISTIC REGRESSION")
params = {
"rbm__learning_rate": [0.1, 0.01, 0.001],
"rbm__n_iter": [20, 40, 80],
"rbm__n_components": [50, 100, 200],
"logistic__C": [1.0, 10.0, 100.0]}
# perform a grid search over the parameter
gs = GridSearchCV(classifier, params, n_jobs = -1, verbose = 1)
gs.fit(self.data, self.target)
print ("best score: %0.3f" % (gs.best_score_))
print ("RBM + LOGISTIC REGRESSION PARAMETERS")
bestParams = gs.best_estimator_.get_params()
for p in sorted(params.keys()):
print ("\t %s: %f" % (p, bestParams[p]))
def main():
cifar = dataset.load(10000)
X, Y = cifar.data, cifar.target
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.2,
random_state=0)
logistic = linear_model.LogisticRegression(C=6000.0)
rbm = BernoulliRBM(n_components=100,
learning_rate=0.025,
batch_size=10,
n_iter=100,
verbose=True)
classifier = Pipeline(steps=[('rbm', rbm), ('logistic', logistic)])
# Training RBM-Logistic Pipeline
classifier.fit(X_train, Y_train)
# Training Logistic regression
logistic_classifier = linear_model.LogisticRegression(C=100.0)
logistic_classifier.fit(X_train, Y_train)
Y_predicted_rbm = classifier.predict(X_test)
Y_predicted_raw = logistic_classifier.predict(X_test)
# Evaluate classifiers
print()
print("Logistic regression using RBM features:\n%s\n" %
(metrics.classification_report(
Y_test, Y_predicted_rbm, target_names=cifar.target_names)))
print("Logistic regression using raw pixel features:\n%s\n" %
(metrics.classification_report(
Y_test, Y_predicted_raw, target_names=cifar.target_names)))
print("Confusion matrix RBM features:\n%s" %
metrics.confusion_matrix(Y_test, Y_predicted_rbm))
print("Confusion matrix raw pixel features:\n%s" %
metrics.confusion_matrix(Y_test, Y_predicted_raw))
# Plot RBM features
plot(rbm, 100)
def RBM():
filename = "../data/smaller.dta"
raw_data = open(filename, 'rt')
data = np.loadtxt(raw_data, delimiter=" ")
X = data[:, :3]
Y = data[:, 3]
print(X)
print(Y)
print("training on RBM")
rbm = BernoulliRBM(random_state=0, verbose=True)
rbm.learning_rate = 0.06
rbm.n_iter = 20
rbm.n_components = 100
rbm.fit(X, Y)
predictions = rbm.transform(X)
params = rbm.get_params()
print("predictions = ", predictions)
print("rbm = ", rbm)
print("params = ", params)
