Python BernoulliRBM.fit_transform方法代码示例

# 需要导入模块: from sklearn.neural_network import BernoulliRBM [as 别名]
# 或者: from sklearn.neural_network.BernoulliRBM import fit_transform [as 别名]
def process_machine_learning(symbol, i, path):
    
    params['path']= path
    label, feature= load_data(params['path'])

    #scales values in features so that they range from 0 to 1
    minmaxScaler = MinMaxScaler()
    feature = minmaxScaler.fit_transform(feature)
    
    print("Dimensions")
    print("label", label.shape)
    print("feature", feature.shape)

    #feature selection using RBM

    start_time = time.time()

    rbm = BernoulliRBM(n_components=params['reduced_feature'], learning_rate=params['learning_rate'], batch_size=params['batchsize'], n_iter=params['n_iter'])
    feature = rbm.fit_transform(feature)

    print("RBM--- %s seconds ---" % (time.time() - start_time))

    print("Dimensions after RBM")
    print("label", label.shape)
    print("feature", feature.shape)

    x_train, x_test, y_train, y_test = train_test_split(feature, label, i)
    y_pred = random_forest(x_train, x_test, y_train)
    signal_pd=pd.DataFrame({'y_test':y_test[:,0],'y_pred':y_pred})
    signal_pd.to_csv(os.path.join('..', 'data', 'rbm_random_forest',symbol,symbol+'_'+str(i)+'.csv'))

# 需要导入模块: from sklearn.neural_network import BernoulliRBM [as 别名]
# 或者: from sklearn.neural_network.BernoulliRBM import fit_transform [as 别名]
def process_machine_learning():
    i_label, i_feature, i_symbol = load_data(params['path'])
    i_pos = i_symbol.rfind('/')+1
    i_symbol = i_symbol[i_pos:i_pos+2]

    #scales values in features so that they range from 0 to 1
    i_minmaxScaler = MinMaxScaler()
    i_feature = i_minmaxScaler.fit_transform(i_feature)

    print("Dimensions")
    print("label", i_label.shape)
    print("feature", i_feature.shape)

    #feature selection using RBM

    i_start_time = time.time()

    i_rbm = BernoulliRBM(n_components=params['reduced_feature'], learning_rate=params['learning_rate'],
                         batch_size=params['batchsize'], n_iter=params['n_iter'])
    i_feature = i_rbm.fit_transform(i_feature)

    print("RBM--- %s seconds ---" % (time.time() - i_start_time))

    print("Dimensions after RBM")
    print("label", i_label.shape)
    print("feature", i_feature.shape)

    i_x_train, i_x_test, i_y_train, i_y_test = train_test_split(i_feature, i_label)
    i_y_pred = random_forest(i_x_train, i_x_test, i_y_train)

    i_filename = 'PRED_'+i_symbol+'-5.csv'
    with open(i_filename, 'wb') as csvfile:
        i_writer = csv.writer(csvfile, delimiter=',')
        for i in range(len(i_y_pred)):
            i_writer.writerow((i_y_pred[i], i_y_test[i][0]))

    print_f1_score(i_y_test, i_y_pred)
    classification_error(i_y_test, i_y_pred)

# 需要导入模块: from sklearn.neural_network import BernoulliRBM [as 别名]
# 或者: from sklearn.neural_network.BernoulliRBM import fit_transform [as 别名]
    symbol = symbol[pos:pos+2]

    #scales values in features so that they range from 0 to 1
    minmaxScaler = MinMaxScaler()
    feature = minmaxScaler.fit_transform(feature)

    print("Dimensions")
    print("label", label.shape)
    print("feature", feature.shape)

    #feature selection using RBM

    start_time = time.time()

    rbm = BernoulliRBM(n_components=params['reduced_feature'], learning_rate=params['learning_rate'], batch_size=params['batchsize'], n_iter=params['n_iter'])
    feature = rbm.fit_transform(feature)

    print("RBM--- %s seconds ---" % (time.time() - start_time))

    print("Dimensions after RBM")
    print("label", label.shape)
    print("feature", feature.shape)

    x_train, x_test, y_train, y_test = train_test_split(feature, label)
    y_pred = random_forest(x_train, x_test, y_train)

    filename = 'PRED_'+symbol+'-5.csv'
    with open(filename, 'wb') as csvfile:
        writer = csv.writer(csvfile, delimiter=',')
        for i in range(len(y_pred)):
            writer.writerow((y_pred[i], y_test[i][0]))

# 需要导入模块: from sklearn.neural_network import BernoulliRBM [as 别名]
# 或者: from sklearn.neural_network.BernoulliRBM import fit_transform [as 别名]
mylist=[]
for u in range(len_test_range):
    clear_output(wait=True)
    print 'Filling dict'
    print str(u)+' of '+str(len_test_range)
    mylist+=[pd.Series(getPerc(test_range[u:u+len_dataset_pattern]))]
mylist=np.array(mylist)


# In[ ]:

from sklearn.mixture import VBGMM
from copy import copy
from sklearn.neural_network import BernoulliRBM
kmeans = BernoulliRBM ()
clusters=pd.Series(kmeans.fit_transform(mylist),name='clusters')


# In[ ]:


c=pd.DataFrame(mylist).join(clusters)
c
d=c.loc[((c.clusters==c.clusters.iloc[-1]))]
d
d=d.iloc[:,:-1]
for x in range(len(d)):
    a=2
    d.iloc[[x,-1]].transpose().plot(linewidth=1)
d.iloc[[x,-1],:]
#.iloc[:,[x,-1]]

# 需要导入模块: from sklearn.neural_network import BernoulliRBM [as 别名]
# 或者: from sklearn.neural_network.BernoulliRBM import fit_transform [as 别名]
#mmodel number 2
#bigMatrixTrain = (bigMatrixTrain - np.min(bigMatrixTrain, 0)) / (np.max(bigMatrixTrain, 0) + 0.0001)  # 0-1 scaling
#Divide dataset for cross validation purposes
X_train, X_test, y_train, y_test = cross_validation.train_test_split(
    bigMatrixTrain, y, test_size = 0.4, random_state = 0) #fix this

# specify parameters and distributions to sample from
# Models we will use
rbm = BernoulliRBM(random_state=0, verbose=True)

#classifier = Pipeline(steps=[('rbm', rbm), ('logistic', logistic)])
rbm.learning_rate = 0.04
rbm.n_iter = 30
# More components tend to give better prediction performance, but larger fitting time
rbm.n_components = 300
X_train = rbm.fit_transform(X_train)
X_test = rbm.transform(X_test)

# Train a logistic model
print("Fitting the classifier to the training set")
logisticModel = linear_model.LogisticRegression()
t0 = time()
param_grid = {'C': [10, 30, 100, 300, 1000]}
logisticModel = GridSearchCV(logisticModel, param_grid = param_grid)
logisticModel = logisticModel.fit(X_train, y_train)
print("done in %0.3fs" % (time() - t0))
print("Best estimator found by grid search:")
print(logisticModel.best_estimator_)

#logistic.C = 6000.0

# 需要导入模块: from sklearn.neural_network import BernoulliRBM [as 别名]
# 或者: from sklearn.neural_network.BernoulliRBM import fit_transform [as 别名]
CMAs = ['Rachelle', 'Karen']
trainSource = CMAs[0]
testSource = CMAs[1]
def getXYforMultiSet(source):
    ds, featuresNames = labanUtil.getPybrainDataSet(source)
    X, Y = labanUtil.fromDStoXY(ds)
    return X, np.transpose(Y)
X, Y = getXYforMultiSet(trainSource)
print X
X_test, Y_test = getXYforMultiSet(testSource)
res = []
params = np.linspace(0.001, 0.1, 10)
for p in params:
    print p
    rbm = BernoulliRBM(n_components=int(p*X.shape[1]), n_iter=1000)
    print rbm.fit_transform(X)
    """
    X_small = rbm.fit_transform(X)
    print X_small.shape
    clf = linear_model.MultiTaskElasticNetCV()
    #clf = Pipeline(steps=[('rbm', rbm), ('MultiTaskElasticNetCV', multiClf)])
    clf.fit(X_small, Y)
    print  np.array(clf.predict(rbm.transform(X_test)))
 
    
    predTrain = np.array(clf.predict(X_small))
    splits = []
    for col in range(predTrain.shape[1]):
        splits.append(getSplitThreshold(predTrain[:, col], Y[:, col]))
    pred =  np.array(clf.predict(rbm.transform(X_test)))
    for col in range(pred.shape[1]):

# 需要导入模块: from sklearn.neural_network import BernoulliRBM [as 别名]
# 或者: from sklearn.neural_network.BernoulliRBM import fit_transform [as 别名]
del rows

folds = StratifiedKFold(information, n_folds=3)

result = []


for train, test in folds:
	data_train = sentences[train]
	result_train = information[train]

	data_test = sentences[test]
	result_test = information[test]

	vectorizer = TfidfVectorizer(binary=True, norm=False, use_idf=False)
	rbm = BernoulliRBM()
	classifier = RandomForestClassifier()

	data_train = vectorizer.fit_transform(data_train)
	data_test = vectorizer.transform(data_test)

	data_train = rbm.fit_transform(data_train)
	data_test = rbm.transform(data_test)

	classifier.fit(data_train, result_train)

	print classificationError(classifier.predict(data_test), result_test)
	result.append(classifier.score(data_test, result_test))

print reduce(lambda x, y: x + y, result) / float(len(result))