def test_lbfgs_regression(): # Test lbfgs on the boston dataset, a regression problems. X = Xboston y = yboston for activation in ACTIVATION_TYPES: mlp = MLPRegressor(solver='lbfgs', hidden_layer_sizes=50, max_iter=150, shuffle=True, random_state=1, activation=activation) mlp.fit(X, y) if activation == 'identity': assert_greater(mlp.score(X, y), 0.84) else: # Non linear models perform much better than linear bottleneck: assert_greater(mlp.score(X, y), 0.95)
def test_multioutput_regression(): # Test that multi-output regression works as expected X, y = make_regression(n_samples=200, n_targets=5) mlp = MLPRegressor(solver='lbfgs', hidden_layer_sizes=50, max_iter=200, random_state=1) mlp.fit(X, y) assert_greater(mlp.score(X, y), 0.9)
def test_lbfgs_regression(): # Test lbfgs on the boston dataset, a regression problems.""" X = Xboston y = yboston for activation in ACTIVATION_TYPES: mlp = MLPRegressor(algorithm='l-bfgs', hidden_layer_sizes=50, max_iter=150, shuffle=True, random_state=1, activation=activation) mlp.fit(X, y) assert_greater(mlp.score(X, y), 0.95)
def test_partial_fit_regression(): # Test partial_fit on regression. # `partial_fit` should yield the same results as 'fit' for regression. X = Xboston y = yboston for momentum in [0, .9]: mlp = MLPRegressor(solver='sgd', max_iter=100, activation='relu', random_state=1, learning_rate_init=0.01, batch_size=X.shape[0], momentum=momentum) with warnings.catch_warnings(record=True): # catch convergence warning mlp.fit(X, y) pred1 = mlp.predict(X) mlp = MLPRegressor(solver='sgd', activation='relu', learning_rate_init=0.01, random_state=1, batch_size=X.shape[0], momentum=momentum) for i in range(100): mlp.partial_fit(X, y) pred2 = mlp.predict(X) assert_almost_equal(pred1, pred2, decimal=2) score = mlp.score(X, y) assert_greater(score, 0.75)
X = create_X(x, y, n=n) # only training data, no advanced splitting X_train = X Y_train = z # only one simple layer with 100 neurons n_hidden_neurons = 100 epochs = 100 # store models for later use eta_vals = np.logspace(-5, 1, 7) lmbd_vals = np.logspace(-5, 1, 7) # store the models for later use DNN_scikit = np.zeros((len(eta_vals), len(lmbd_vals)), dtype=object) train_accuracy = np.zeros((len(eta_vals), len(lmbd_vals))) sns.set() for i, eta in enumerate(eta_vals): for j, lmbd in enumerate(lmbd_vals): dnn = MLPRegressor(hidden_layer_sizes=(n_hidden_neurons), activation='logistic', alpha=lmbd, learning_rate_init=eta, max_iter=epochs) dnn.fit(X_train, Y_train) DNN_scikit[i][j] = dnn train_accuracy[i][j] = dnn.score(X_train, Y_train) fig, ax = plt.subplots(figsize = (10, 10)) sns.heatmap(train_accuracy, annot=True, ax=ax, cmap="viridis") ax.set_title("Training Accuracy") ax.set_ylabel("$\eta$") ax.set_xlabel("$\lambda$") plt.show()
from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split from sklearn.neural_network import MLPRegressor scaler = StandardScaler() #X_train, X_test, y_train, y_test = train_test_split(train_data, train_target, test_size=0.20, random_state=0) #X_train_scaled = scaler.fit(X_train).transform(X_train) #X_test_scaled = scaler.fit(X_test).transform(X_test) train_data_scaled = scaler.fit_transform(train_data) test_data_scaled = scaler.fit_transform(test_data) acc_train = [] acc_test = [] alp = [0.0001, 0.001, 0.01, 0.1, 1] for i in range(1, 100, 10): for j in alp: mlp = MLPRegressor(max_iter = 200, solver='lbfgs', hidden_layer_sizes = (i, i), alpha = j, activation='identity') mlp.fit(train_data, train_target) acc_train.append(mlp.score(train_data, train_target)) acc_test.append(mlp.score(test_data, test_target)) print(np.reshape(acc_test, (5, 10))) print(np.amax(acc_test)) #print(len(acc_test)) #print(np.amax(acc_train))
N_data = len(X) N_train = int(0.8 * N_data) N_test = N_data - N_train X_train = X.iloc[0:N_train, :] X_test = X.iloc[N_train + 1:N_data - 1, :] y_train = y.iloc[0:N_train] y_test = y.iloc[N_train + 1:N_data - 1] mlp = MLPRegressor(hidden_layer_sizes=(10, )) mlp.fit(X_train, y_train) y_pred_mlp = mlp.predict(X_test) #Compute R^2 and root mean squared error print("R^2 = {}".format(mlp.score(X_test, y_test))) rmse_mlp = np.sqrt(mean_squared_error(y_test, y_pred_mlp)) print("Root mean square error = {}".format(rmse_mlp)) y_test_pred_mlp = pd.DataFrame({ 'y_test': y_test, 'y_pred_mlp': y_pred_mlp }, index=X_test.index) y_test_pred_mlp.plot(legend=True) plt.title('MLP Apple Stock Prediction') reg = LinearRegression() reg.fit(X_train, y_train) y_pred_reg = reg.predict(X_test)
#X_train = scaler.transform(X_train) #X_test = scaler.transform(X_test) trainSize = len(X) / 4 * 3 X_train = X[:trainSize] y_train = y[:trainSize] X_val = X[trainSize:] y_val = y[trainSize:] mlp = MLPRegressor(hidden_layer_sizes=( 100, 50, ), random_state=1, max_iter=1, warm_start=True, learning_rate_init=0.000001) for i in range(1000): mlp.fit(X_train, y_train) if (i % 100 == 0): #print("Validation set score: %f" % mlp.score(X_val, y_val)) #print("Training set score: %f" % mlp.score(X_train, y_train)) p = mlp.predict(X_val) mse = MSE(y_val, p) rmse = sqrt(mse) print rmse print("Training set score: %f" % mlp.score(X_train, y_train))
import sklearn as sk from sklearn.model_selection import train_test_split from sklearn.neural_network import MLPRegressor import numpy as np import random a = np.random.uniform(0, 1, 500) b = np.random.uniform(0, 1, 500) d = a * b data = np.array(list(zip(a, b))) print(data) total = 0 for i in range(30): XTrain, XTest, YTrain, YTest = train_test_split(data, d, test_size=0.2) clf = MLPRegressor(hidden_layer_sizes=(50, 50), activation='relu', solver='lbfgs') clf = clf.fit(XTrain, YTrain) out = clf.score(XTest, YTest) total += out print("Output on is:", total / 30)
# Escalonamento da variável de resposta Y scaler_y = StandardScaler() y = scaler_y.fit_transform(y) # ==== Criação da base de dadtos trienamento (70%) e base de teste (30%) ======= from sklearn.model_selection import train_test_split X_treinamento, X_teste, y_treinamento, y_teste = train_test_split( X, y, test_size=0.3, random_state=0) # Importação e implemantação de rede neural from sklearn.neural_network import MLPRegressor regressor = MLPRegressor(hidden_layer_sizes=(9, 9)) # ===== Gerando o treinamento ===== regressor.fit(X_treinamento, y_treinamento) # ==== Visualizando o valor do score para saber como esta se comportando o previssor ==== score = regressor.score(X_treinamento, y_treinamento) # ==== Visualizando o valor do score para saber como esta se comportando a resposta ==== regressor.score(X_teste, y_teste) # ===== Realizando algumas previssões ===== previsoes = regressor.predict(X_teste) y_teste = scaler_y.inverse_transform(y_teste) previsoes = scaler_y.inverse_transform(previsoes) # ===== Outra maneira de visualizar a diferença ===== from sklearn.metrics import mean_absolute_error mae = mean_absolute_error(y_teste, previsoes)
#KNN knn = KNeighborsRegressor() knn.fit(X_16, y_16) knn_score = knn.score(X_17,y_17) #svm svm = SVR() svm.fit(X_16, y_16) svm_score = svm.score(X_17,y_17) # #xgboost # xgb = xgboost.XGBRegressor() # xgb.fit(X_16, y_16) # xgb_score = xgb.score(X_17,y_17) #mlp regressor mlp = MLPRegressor(hidden_layer_sizes = (100,100,100,100), random_state=444) mlp.fit(X_16,y_16) mlp_score = mlp.score(X_17, y_17) #Combine all models into one data frame mlp_predicts = mlp.predict(X_16) hour_totals_17['Predicted_mlp'] = pd.Series(mlp_predicts) hour_totals_17['Crimes'] = hour_totals_17['Crimes']/365 hour_totals_17['Predicted_mlp'] = hour_totals_17['Predicted_mlp']/365 hour_totals_17 = np.round(hour_totals_17,2) hour_totals_17.to_json("./nairobi_crime_predictions.json", orient='records', double_precision=2)
fit_time = fit_end - fit_start fit_min = int(fit_time / 60) fit_sec = fit_time % 60 print( 'Fitting completed in {} minutes {} seconds. Saving model to .pkl file \n' .format(fit_min, fit_sec)) model_filename = model_folder + output_text + '_and_alpha' + str( av) + '.pkl' joblib.dump(nn_model, model_filename) print('Predicting...\n') y_pred_train = nn_model.predict(X_t) print('Validating...\n') y_pred_val = nn_model.predict(X_val) print('Getting scores\n') scr = nn_model.score(X_t, y_t) scr_val = nn_model.score(X_val, y_val) scrs.append(scr) scrs_val.append(scr_val) rmse_train_pers = (np.mean( (y_pred_persistence - y_t)**2))**0.5 #our persistence score rmse_val_pers = (np.mean( (y_pred_persistence_val - y_val)**2))**0.5 rmse_train_pers_scores.append(rmse_train_pers) rmse_validation_pers_scores.append(rmse_val_pers) rmse_val = (np.mean((y_pred_val - y_val)**2))**0.5 rmse_train = (np.mean((y_pred_train - y_t)**2))**0.5
from sklearn.neural_network import MLPRegressor from sklearn.model_selection import train_test_split data = pd.read_csv("new_dataset.csv") data.head() data = data.drop(columns='id') data = data.drop(columns='date') data.head() y = data.loc[:, 'price'] X = data.drop(columns='price') # 1 using input data #with open('input.txt') as my_file: # test_array = my_file.readlines() #regressor = MLPRegressor(random_state=0) #regressor.fit(X, y) #y_pred = regressor.predict(np.array(test_array).reshape(1, 16)) #sc_X = StandardScaler() #sc_y = StandardScaler() #X = sc_X.fit_transform(X) #y = sc_y.fit_transform(y) #2 using train data X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=0) regressor = MLPRegressor(random_state=0) regressor.fit(X_train, y_train) y_pred = regressor.predict(np.array(X_test)) print('evaluating estimator performance: '+str(regressor.score(X_test, y_test))) print(str(int(y_pred[0])) + '$')
X_train = pd.read_csv(result["TrainFileName"], usecols=result["OtherAttributes"]) y_train = pd.read_csv(result["TrainFileName"], usecols=[result["RequiredAttribute"]]) X_test = pd.read_csv(result["TestFileName"], usecols=result["OtherAttributes"]) y_test = pd.read_csv(result["TestFileName"], usecols=[result["RequiredAttribute"]]) model = MLPRegressor(hidden_layer_sizes=(10, 10), activation='relu') model.fit(X_train, y_train) y_pred = model.predict(X_test) print(model.score(X_test, y_test)) print(mean_absolute_error(y_test, y_pred)) print(sqrt(mean_squared_error(y_test, y_pred))) y_actual = y_test.values y_actual = [i for v in y_actual for i in v] y_obs = [i for i in y_pred] x_axis = [] for i in range(715): x_axis.append(i) plt.figure() plt.plot(x_axis, y_actual, color='b', label='actual') plt.plot(x_axis, y_pred, color='r', label='predicted')
activation='tanh', solver='sgd', learning_rate_init=0.01, max_iter=1000, random_state=1, validation_fraction=0.1) ###################################################################################################################### cv = KFold(n_splits=10, random_state=1, shuffle=True) for train_index, test_index in cv.split(x): X_train, X_test, y_train, y_test, yy_train, yy_test = x[train_index], x[ test_index], y[train_index], y[test_index], yy[train_index], yy[ test_index] # MLP_Regressor_1.fit(X_train.values.reshape(-1, 1), yy_train) scores_1.append( MLP_Regressor_1.score(X_test.values.reshape(-1, 1), yy_test)) # MLP_Regressor_2.fit(X_train.values.reshape(-1, 1), yy_train) scores_2.append( MLP_Regressor_2.score(X_test.values.reshape(-1, 1), yy_test)) # MLP_Regressor_3.fit(X_train.values.reshape(-1, 1), yy_train) scores_3.append( MLP_Regressor_3.score(X_test.values.reshape(-1, 1), yy_test)) # MLP_Regressor_4.fit(X_train.values.reshape(-1, 1), yy_train) scores_4.append( MLP_Regressor_4.score(X_test.values.reshape(-1, 1), yy_test)) # MLP_Regressor_5.fit(X_train.values.reshape(-1, 1), yy_train) scores_5.append(
class NeuralNetwork: ################# Fields ####################### # dataset_filename: string - path to dataset # header: list - header of the dataset # enumerable_columns: list - the enumerable columns # df: matrix - data set # training_set: matrix - training set # test_set: matrix - test set # TSnew_X: matrix - training set of TSnew (see documentation) # TSnew_Y: matrix - training set of TSnew (see documentation) # dim_random_subset: int - number of features to set to 0 (see documentation) # repeatSometimes: int - number of for cicles (see documentation) def __init__(self, repeatSometimes = 2, dim_random_subset = 2): # variables initialization self.enumerable_columns = [] self.dataset_filename = "" self.header = [] self.df = pandas.DataFrame() self.trainSet = pandas.DataFrame() self.testSet = pandas.DataFrame() self.TSnew_X = pandas.DataFrame() self.TSnew_Y = pandas.DataFrame() self.repeatSometimes = repeatSometimes self.dim_random_subset = dim_random_subset # This code really needs much time and therefore I save some computations if not os.path.isfile('trainSet{}-{}.csv'.format(repeatSometimes, dim_random_subset)): self.readDataset() self.discretization() self.preprocess() # creating TSnew self.createTrainingAndTestSet() self.createTSnew() # backup encoded sets self.writeCSV() else: self.readCSV() # training and test self.train() self.predict() def readDataset(self): print("DEB Read dataset") with open('header.txt') as f: self.header = f.read().split(',') print(self.header) with open('dataset.txt') as f: self.dataset_filename = f.read() print(self.dataset_filename) self.df = pandas.read_csv(self.dataset_filename, names=self.header) print('Dataset with {} entries'.format(self.df.__len__())) ############# Preprocessing ########################## # helper function (should not be called from other functions) def discretize(self, column): print("DEB Discretize column " + column) sorted_col = sorted(column) l = len(column) n = int(numpy.floor(l / 2)) if l % 2 == 0: median_1 = numpy.median(sorted_col[0:n]) median_2 = numpy.median(sorted_col[n:]) else: median_1 = numpy.median(sorted_col[0:(n + 1)]) median_2 = numpy.median(sorted_col[(n + 1):]) iqr = median_2 - median_1 h = 2 * iqr * (1 / numpy.cbrt(l)) if h > 0: bins_number = numpy.ceil((column.max() - column.min()) / h) new_col, bins = pandas.cut(column, bins_number, labels=False, retbins=True, include_lowest=False) else: new_col = column bins = [] return new_col, bins # helper function (should not be called from other functions) def normalize(column): print("DEB Normalize") h = abs(column.min()) new_col = column + h return new_col def discretization(self): print("DEB Discretization") replacements = {} bins = {} for i in range(0, self.df.shape[1]): # for each feature bins[i] = [] col = self.df.as_matrix()[:, i] flag_str = False flag_float = False flag_negative = False for j in col: if type(j) is str: flag_str = True elif type(j) is float: flag_float = True elif type(j) is int and j < 0: flag_negative = True if flag_str: continue elif flag_negative: new_col = self.normalize(col) replacements[i] = new_col bins[i] = [] elif flag_float: new_col, new_bins = self.discretize(col) replacements[i] = new_col bins[i] = new_bins for k, v in replacements.items(): self.df.iloc[:, k] = v def preprocess(self, removeColumnsWithMissingValues = False): print("DEB Preprocessing") m = self.df.as_matrix() # it is possible to encode enumerable features and to remove missing values with open('enumerable_columns.txt') as f: # e.g., self.enumerable_columns = [0, 5, 8] self.enumerable_columns = f.read() if self.enumerable_columns.__contains__(','): self.enumerable_columns = list(map(int, self.enumerable_columns.split(','))) else: self.enumerable_columns = [int(self.enumerable_columns)] print("enumerable columns are: " + str(self.enumerable_columns)) le = preprocessing.LabelEncoder() for col in self.enumerable_columns: # if the column is enumerable self.df[self.header[col]] = le.fit_transform(self.df[self.header[col]]) # A -> 0, B -> 1, ... # remove cols with missing values (NaN), even though you risk to reduce too much the dataset if removeColumnsWithMissingValues: for i in range(0, m.shape[1]): if True in m[:, i]: self.df = numpy.delete(self.df, 0, i) # delete column ############## MPL architecture ####################### def createTrainingAndTestSet(self): print("DEB Create Training set. Using formula 80-20%") self.trainSet, self.testSet = train_test_split(self.df, test_size=0.20) # hearth of the algorithm! def createTSnew(self): print("DEB Create TS new") for i in range(0, self.trainSet.shape[0]): for j in range(0, self.repeatSometimes): # choose small random subset of features X_hat X_hat = [int(self.trainSet.shape[1] * random.random()) for i in range(0, self.dim_random_subset)] # insert into TSnew the sample: (x1...X_hat = 0 ... xk ; x1...xk) row = numpy.copy(self.trainSet.as_matrix()[i, :]) for feature in X_hat: # here you set the random features to 0. X_hat represents the indices of such features row[feature] = 0 self.TSnew_X = self.TSnew_X.append(pandas.DataFrame(row.reshape(-1, len(row)))) # append row to TSnew_X copy = numpy.copy(self.trainSet.as_matrix()[i, :]) self.TSnew_Y = self.TSnew_Y.append(pandas.DataFrame(copy.reshape(-1, len(copy)))) # Y = x1...xk ############## Train & Predict ######################## def train(self): print("DEB Training with TSnew") self.MLP = MLPRegressor(activation='relu', alpha=1e-05, batch_size='auto', beta_1=0.9, beta_2=0.999, early_stopping=False, epsilon=1e-08, hidden_layer_sizes=len(self.TSnew_Y.columns), learning_rate='constant', learning_rate_init=0.001, max_iter=200, momentum=0.9, nesterovs_momentum=True, power_t=0.5, random_state=1, shuffle=True, solver='lbfgs', tol=0.0001, validation_fraction=0.1, verbose=False, warm_start=False) self.MLP.fit(self.TSnew_X, self.TSnew_Y) def predict(self): print("DEB Test") testSetNew_X = pandas.DataFrame() testSetNew_Y = pandas.DataFrame() # preparing the test set - here you do the same as in function createTSnew: if not os.path.isfile('testSetNew_X{}-{}.csv'.format(self.repeatSometimes, self.dim_random_subset)): for i in range(0, self.testSet.shape[0]): # choose small random subset of features X_hat X_hat = [int(self.testSet.shape[1] * random.random()) for i in range(0, self.dim_random_subset)] # insert into TSnew the sample: (x1...X_hat = 0 ... xk ; x1...xk) row = numpy.copy(self.testSet.as_matrix()[i, :]) for feature in X_hat: # here you set the random features to 0. X_hat represents the indices of such features row[feature] = 0 testSetNew_X = testSetNew_X.append(pandas.DataFrame(row.reshape(-1, len(row)))) copy = numpy.copy(self.testSet.as_matrix()[i, :]) testSetNew_Y = testSetNew_Y.append(pandas.DataFrame(copy.reshape(-1, len(copy)))) # Y = x1...xk testSetNew_Y.to_csv('testSetNew_X{}-{}.csv'.format(self.repeatSometimes, self.dim_random_subset)) testSetNew_Y.to_csv('testSetNew_Y{}-{}.csv'.format(self.repeatSometimes, self.dim_random_subset)) else: # if the needed DataFrames have already been calculated, simply load them from disk self.trainSet = self.trainSet.from_csv('testSetNew_X{}-{}.csv'.format(self.repeatSometimes, self.dim_random_subset)) self.trainSet = self.trainSet.from_csv('testSetNew_Y{}-{}.csv'.format(self.repeatSometimes, self.dim_random_subset)) # predictions self.MLP.predict(testSetNew_X) print("Score of method (repetitions={}, subset={}): {}%".format(self.repeatSometimes, self.dim_random_subset, self.MLP.score(testSetNew_X, testSetNew_Y) * 100)) ########################## Helper functions #################### def writeCSV(self): print("DEB WriteCSV") self.trainSet.to_csv('trainSet{}-{}.csv'.format(self.repeatSometimes, self.dim_random_subset)) self.testSet.to_csv('testSet{}-{}.csv'.format(self.repeatSometimes, self.dim_random_subset)) self.TSnew_X.to_csv('TSnew_X{}-{}.csv'.format(self.repeatSometimes, self.dim_random_subset)) self.TSnew_Y.to_csv('TSnew_Y{}-{}.csv'.format(self.repeatSometimes, self.dim_random_subset)) def readCSV(self): print("DEB ReadCSV") self.trainSet = self.trainSet.from_csv('trainSet{}-{}.csv'.format(self.repeatSometimes, self.dim_random_subset)) self.testSet = self.testSet.from_csv('testSet{}-{}.csv'.format(self.repeatSometimes, self.dim_random_subset)) self.TSnew_X = self.TSnew_X.from_csv('TSnew_X{}-{}.csv'.format(self.repeatSometimes, self.dim_random_subset)) self.TSnew_Y = self.TSnew_Y.from_csv('TSnew_Y{}-{}.csv'.format(self.repeatSometimes, self.dim_random_subset))
def runMLP(hd_layers_p=(30, ), activation_p='tanh', solver_p='adam', learn_rate_p=0.001, early_stopping_p=True, momentum_p=0.9, max_iter_p=1000): k_fold_lenght = 4 scoreList = [] MLPs = [] y_Test_Total = [] y_Pred_Total = [] (X, y) = readData() #(X_Train_Container, y_Train_Container, X_Test_Container,y_Test_Container) = dataStratification(X, y, k_fold_lenght) #for i in range(k_fold_lenght): mlp = MLPRegressor(hidden_layer_sizes=hd_layers_p, activation=activation_p, solver=solver_p, learning_rate_init=learn_rate_p, max_iter=max_iter_p, momentum=momentum_p) #Get subsets X_Train, X_Test, y_Train, y_Test = train_test_split(X, y, test_size=0.33, random_state=42) print 'Size of X_Train: ' + str(len(X_Train)) print 'Size of y_Train: ' + str(len(y_Train)) print 'Size of X_Test: ' + str(len(X_Test)) print 'Size of y_Test: ' + str(len(y_Test)) y_Test_Total += y_Test #Scale scaler = StandardScaler() scaler.fit(X_Train) X_Train = scaler.transform(X_Train) X_Test = scaler.transform(X_Test) #Train mlp.fit(X_Train, y_Train) #print "Weight matrix", mlp.coefs_ #Test scoreList.append(mlp.score(X_Test, y_Test)) #y_Pred_Total += mlp.predict(X_Test) print "\tTest score ", "\t", scoreList[0] #end for #End Train and run MLP mean = 0 for score in scoreList: mean += score mean = mean / len(scoreList) #print vetor1 #print type(vetor1) #cnf_matrix = confusion_matrix(y_Test_Total,y_Pred_Total) #print cnf_matrix np.set_printoptions(precision=2) # Plot non-normalized confusion matrix #plt.figure() #plot_confusion_matrix(cnf_matrix, classes=['M','F','I'], # title='Confusion matrix, without normalization') # Plot normalized confusion matrix #plt.figure() #plot_confusion_matrix(cnf_matrix, classes=['M','F','I'], normalize=True, # title='Normalized confusion matrix') #plt.show() return mean
confidence1kfold = model_selection.cross_val_score(clf1, X, y, cv=kfold) print("SVR (KFold) : %.3f%% (%.3f%%)" % (confidence1kfold.mean() * 100.0, confidence1kfold.std() * 100.0)) clf1.fit(X_train, y_train) confidence1 = clf1.score(X_test, y_test) print("SVR : %.3f%%" % (confidence1 * 100.0)) clf2 = MLPRegressor() confidence2kfold = model_selection.cross_val_score(clf2, X, y, cv=kfold) print("MLP (KFold) : %.3f%% (%.3f%%)" % (confidence2kfold.mean() * 100.0, confidence2kfold.std() * 100.0)) clf2.fit(X_train, y_train) confidence2 = clf2.score(X_test, y_test) print("MLP : %.3f%%" % (confidence2 * 100.0)) clf = LinearRegression() confidencekfold = model_selection.cross_val_score(clf, X, y, cv=kfold) print("LR (KFold) : %.3f%% (%.3f%%)" % (confidencekfold.mean() * 100.0, confidencekfold.std() * 100.0)) clf.fit(X_train, y_train) confidence = clf.score(X_test, y_test) print("LR : %.3f%%" % (confidence * 100.0)) #Add forecasting code for submission on 11th November, 2017 forecast_set = clf.predict(X_lately) #print(forecast_set, confidence, forecast_out)
缺点: 受权重的影响大 需要调节很多超参数 对特征的缩放很敏感 复杂度:O(n*m*h^k*o*i) n——样本数 m——特征数 h——隐藏层数 k——神经元数量 o——输出神经元 i——迭代次数 ''' rg = MLPRegressor(hidden_layer_sizes=(100, ), activation='relu', solver='adam', alpha=0.0001, batch_size='auto', learning_rate='constant', learning_rate_init=0.001, power_t=0.5, max_iter=200, shuffle=True, random_state=None, tol=0.0001, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True, early_stopping=False, validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08) rg.fit(X_train,Y_train) Y_pre = rg.predict(X_test) rg.score(X_test,Y_test) rg.loss_ ''' hidden_layer_sizes 第i个元素表示第i个隐藏层中神经元的数量 activation 隐藏层的激活函数 identity f(x) = x logistic f(x) = 1 / (1 + exp(-x)) tanh f(x) = tanh(x) relu f(x) = max(0, x) solver 权重优化方法 lbfgs 标准牛顿法 sgd 随机梯度下降 adam 随机梯度优化法,没见过... alpha L2正则化项的惩罚系数 batch_size 使用随机梯度优化法时,minibatch的样本数 learning_rate 权重更新的学习速度
#Round y_pred to nearest integer due to PWM mechanical constraints #------------------------- for i in range(len(y_pred)): if math.modf(y_pred[i])[0]>0.5: y_pred[i]=math.ceil(y_pred[i]) else: y_pred[i]=math.floor(y_pred[i]) #-------------------------- #METRICS #------------------------- print ('Number of points used for training : ' + str(len(X_train))) print ('Number of points used for test : ' + str(len(X_test))) #R2 score R2=mymodel.score(X_test,y_test) print('R2 score = ' + str(R2)) #compute sum of squared errors sse=((y_pred-y_true)**2).sum() #absolute error (vector) error=np.abs(y_true - y_pred) #absolute percent error (vector) aperr= np.abs((y_true - y_pred) / y_true) #MAPE mape=np.mean(np.abs((y_true - y_pred) / y_true)) print('MAPE = ' + str(mape)) #-------------------------- #PLOT #-------------------------
for k in range(4): # 配置MLP(BP算法)的参数,尝试改变hidden_layer_sizes ref = MLPRegressor( solver='lbfgs', alpha=0, hidden_layer_sizes=( 5*(k+1)), #尝试改变“10” tol=1e-6, random_state=20) #‘lbfgs’ is an optimizer in the family of quasi-Newton methods. # alpha : L2 penalty (regularization term) parameter. # hidden_layer_sizes :The ith element represents the number of neurons in # the ith hidden layer. # 模型训练及评价 ref.fit(X_train, y_train) print('训练集-判定系数R^2为:{0:.2f}'.format(ref.score(X_train, y_train))) print('测试集-判定系数R^2为:{0:.2f}'.format(ref.score(X_test, y_test))) # 画出回归曲线 y_predict = ref.predict(X_train) plt.subplot(221+k) plt.scatter(X_train, y_train, s=5, c='k', marker='.') plt.plot(X_train, y_predict,color='r',linewidth=4) plt.xlabel('x') plt.ylabel('y') plt.grid(True) plt.show()
(X_test[:, 2] - .5)**2 + 10 * X_test[:, 3] + 5 * X_test[:, 4]**5 + np.random.normal(0, 1)) lr = LinearRegression(normalize=True) lr.fit(X_train, Y_train) lasso = Lasso(alpha=0.01) lasso.fit(X_train, Y_train) ridge = Ridge(alpha=0.1) ridge.fit(X_train, Y_train) rfr = RandomForestRegressor() rfr.fit(X_train, Y_train) mlp = MLPRegressor(hidden_layer_sizes=(200, ), max_iter=1000) mlp.fit(X_train, Y_train) from sklearn.metrics import accuracy_score acc_lr = lr.score(X_test, Y_test) acc_lasso = lasso.score(X_test, Y_test) acc_ridge = ridge.score(X_test, Y_test) acc_rfr = rfr.score(X_test, Y_test) acc_mlp = mlp.score(X_test, Y_test) print("LinearRegression: ", acc_lr) print("Lasso: ", acc_lasso) print("Ridge: ", acc_ridge) print("RandomForestRegressor: ", acc_rfr) print("MLPRegressor: ", acc_mlp)
warm_start=False, momentum=0.9, nesterovs_momentum=True, early_stopping=False, validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08) # Train the model using the training sets regr.fit(diabetes_X_train, diabetes_y_train) # Make predictions using the testing set diabetes_y_pred = regr.predict(diabetes_X_test) pontos = regr.score(diabetes_X_test, diabetes_y_test) # The coefficients print('Coefficients: \n', pontos) # The mean squared error print("Mean squared error: %.2f" % mean_squared_error(diabetes_y_test, diabetes_y_pred)) # Explained variance score: 1 is perfect prediction print('Variance score: %.2f' % r2_score(diabetes_y_test, diabetes_y_pred)) # Plot outputs plt.scatter(diabetes_X_test, diabetes_y_test, color='black') plt.plot(diabetes_X_test, diabetes_y_pred, color='blue', linewidth=3) plt.xticks(()) plt.yticks(())
MLPRegressorModel = MLPRegressor(activation='relu', solver='adam', learning_rate='adaptive', hidden_layer_sizes=(15), max_iter=1000, batch_size=5, random_state=33) # 0.8281730812610498 MLPRegressorModel.fit(X_train, y_train) # print(MLPRegressorModel.get_params) # print("="*10) # ---------------------------------------------------- # Calculating Details print('MLPRegressorModel Train Score is : ', MLPRegressorModel.score(X_train, y_train)) print('MLPRegressorModel Test Score is : ', MLPRegressorModel.score(X_test, y_test)) print("=" * 10) # --------------------- print("Number of outputs : ", MLPRegressorModel.n_outputs_) print('MLPRegressorModel last activation is : ', MLPRegressorModel.out_activation_) print('MLPRegressorModel No. of layers is : ', MLPRegressorModel.n_layers_) print('MLPRegressorModel No. of iterations is : ', MLPRegressorModel.n_iter_) print("The number of training samples seen by the solver during fitting : ", MLPRegressorModel.t_) print("=" * 10) # --------------------- print('MLPRegressorModel loss is : ', MLPRegressorModel.loss_) print("MLPRegressorModel best loss is : ",
Calculating RMSE for all 6 cases ---------------------------------------------------------------------- """ RMSE1=mean_squared_error(y_test1, y_pred1, squared=False) print("RMSE: ", RMSE1) RMSE2=mean_squared_error(y_test2, y_pred2, squared=False) print("RMSE: ", RMSE2) RMSE3=mean_squared_error(y_test3, y_pred3, squared=False) print("RMSE: ", RMSE3) RMSE4=mean_squared_error(y_test4, y_pred4, squared=False) print("RMSE: ", RMSE4) RMSE5=mean_squared_error(y_test5, y_pred5, squared=False) print("RMSE: ", RMSE5) RMSE6=mean_squared_error(y_test6, y_pred6, squared=False) print("RMSE: ", RMSE6) score= MLP1.score( x_test1, y_test1, sample_weight=None) print(score) score= MLP2.score( x_test2, y_test2, sample_weight=None) print(score) score= MLP3.score( x_test3, y_test3, sample_weight=None) print(score) score= MLP4.score( x_test4, y_test4, sample_weight=None) print(score) score= MLP5.score( x_test5, y_test5, sample_weight=None) print(score) score= MLP6.score( x_test6, y_test6, sample_weight=None) print(score) """ Plotting loss functions as a function of iterations ----------------------------------------------------------------------
def apply_regression(filename): reply_message = "" # read filename containing data from commandline argument # filename = sys.argv[1] input, output = load_all(filename) input = array(input) output = array(output) # freq = array(freq); # normalize degrees and ranks between [0,1] MaxInput = max(input) MaxOutput = max(output) MinInput = min(input) MinOutput = min(output) input = input - MinInput output = output - MinOutput input = input / float(MaxInput - MinInput) output = output / float(MaxOutput - MinOutput) if pri > 2: printV(zip(input, output)) print input.shape, output.shape N = len(input) # Shuffle input and output array together x = np.arange(1, len(input)) np.random.shuffle(x) shuf = x[:] comb = zip(x, input) comb = sorted(comb) input = [x[1] for x in comb] comb = zip(shuf, output) comb = sorted(comb) output = [x[1] for x in comb] input = array(input) output = array(output) input = input.reshape(-1, 1) # output = output.reshape(-1,1); # split data into training and testing instances splitRatio = 0.8 # splitRatio determines how many instances are used for training and testing. eg: 0.2 means 20% train, 80% test spl = int(splitRatio * N) # split location for train-test print "Train : ", int(splitRatio * N), "\t Test: ", int( (1.0 - splitRatio) * N) reply_message += '\n' + "Train : " + str(int( splitRatio * N)) + "\t Test: " + str(int((1.0 - splitRatio) * N)) trI = array(input[:spl]) trL = array( output[:spl]) # trI - training instances, trL - training labels teI = array(input[spl:]) teL = array(output[spl:]) # teI - testing instances, teL - testing labels trI = trI.astype('float') teI = teI.astype('float') # set parameters of neural network regression model nn = MLPRegressor(hidden_layer_sizes=(100, 50), activation='relu', solver='lbfgs', alpha=0.0001, batch_size='auto', learning_rate='adaptive', learning_rate_init=0.001, max_iter=200, shuffle=True, random_state=None, tol=0.00001, verbose=False, momentum=0.5, early_stopping=True, validation_fraction=0.15) print trI.shape, trL.shape # train NN regression model nn.fit(trI, trL) # test model to get accuracy res = nn.score(teI, teL) # 'res' represents how well regression model is learned. # It is defined as (1 - u/v), where u is the residual sum of squares ((y_true - y_pred) ** 2).sum() # and v is the total sum of squares ((y_true - y_true.mean()) ** 2).sum() print 'Accuracy measure: ', res reply_message += '\n' + 'Accuracy measure: ' + str(res) # predict label/output for test instances/degrees for calculating error yres = nn.predict(teI) R = [] # output Dev = [] # deviation from true output sum = 0 if pri > 1: print 'Predicted', '\t', 'Actual' # calculate deviation from true output for each test instance for e in sorted(zip(yres, teL, teI)): prank = (e[0] * (MaxOutput - MinOutput)) + MinOutput # predicted output trank = (e[1] * (MaxOutput - MinOutput)) + MinOutput # true output if (pri > 1): print(e[2] * (MaxInput - MinInput)) + MinInput, "\t", int( prank), "\t", trank sum += abs(prank - trank) R.append(e[1]) Dev.append(abs(prank - trank)) print 'Avg error: ', (sum / len(yres)) reply_message += '\n' + 'Avg error: ' + str(sum / len(yres)) # =============================================================================== # # # save plot image of input vs output on log scale # plt.plot(input,output,'o',ms=1.5) # # savefig(filename+".png"); # # plt.clf(); # #plt.plot(R,Dev,'o',ms=1.5) # #plt.show() # =============================================================================== # correct predicted output < 1 to 1(e^0) # yres = [ max(0,x) for x in yres ] # show plot of predicted output(dotted line) and actual output (continuous line). # NOTE : x-axis is input. Both input(x-axis) and output(y-axis) are on log scale and normalized # if pri > 1 : # z = array(sorted(zip(teI, teL, yres))); # plt.plot(z[:, 0], z[:, 2], 'o', ms=4) # plt.plot(z[:, 0], z[:, 1], '-', ms=2) # plt.show() return reply_message # apply_regression("testfile.txt") # apply_regression("dp_data.txt")
else: inputs.append(float(splitted[j])) test.append(inputs) with open(path4) as f2: lines = f2.readlines() for l in islice(lines, 8000, 10044): test_y.append(float(l.strip())) values = np.array(stringlabeltest) print(values) label_encoder = LabelEncoder() integer_encoded = label_encoder.fit_transform(values) print(integer_encoded) onehot_encoder = OneHotEncoder(sparse=False) integer_encoded = integer_encoded.reshape(len(integer_encoded), 1) onehot_encoded = onehot_encoder.fit_transform(integer_encoded) print(onehot_encoded) for x in range(len(test)): test[x].extend(onehot_encoded[x]) mlp = MLPRegressor(hidden_layer_sizes=(1000, 1000), batch_size=100, solver='adam', learning_rate_init=0.001, max_iter=100) mlp.fit(train, train_y) print(mlp.score(train, train_y)) print(mlp.score(test, test_y))
from sklearn import linear_model from sklearn.svm import SVR from sklearn.pipeline import make_pipeline from sklearn.neural_network import MLPRegressor import numpy as np df = pd.read_excel("dataStandard.xlsx") df_test = df.iloc[:200, :] df_train = df.iloc[201:, :] X = df_train[[ 'Price Points', 'Space Points', 'Placement Points', 'Min Price', 'Max Price' ]] y = df_train[['Quality Points']] regr = MLPRegressor(random_state=1, max_iter=500).fit(X, y) regr.predict(df_test[[ 'Price Points', 'Space Points', 'Placement Points', 'Min Price', 'Max Price' ]]) scoreCalMLP = regr.score( df_test[[ 'Price Points', 'Space Points', 'Placement Points', 'Min Price', 'Max Price' ]], df_test[["Quality Points"]]) print(scoreCalMLP)
def calculate(frame, data): # create list of budget, user_rating, runtimes, release year and cast fb likes for correlation analysis budget = [] user = [] fb_likes = [] runtime = [] release = [] for pt in data: budget.append(pt.budget) user.append(pt.rating) fb_likes.append(pt.fb_likes) runtime.append(pt.runtime) release.append(pt.release) # Calculate correlations among numerical data types p_fb_likes = pearsonr(fb_likes, user) p_budget = pearsonr(budget, user) p_runtime = pearsonr(runtime, user) p_release = pearsonr(release, user) s_fb_likes = spearmanr(fb_likes, user) s_budget = spearmanr(budget, user) s_runtime = spearmanr(runtime, user) s_release = spearmanr(release, user) # set up mlp to perform user rating prediction mlp = MLPRegressor(hidden_layer_sizes=(20, 20), activation='tanh', solver='adam', max_iter=500, verbose=True) data_pts = data random.shuffle(data_pts) data_array = np.array(data_pts) X = data_array[:, 0:-1] Y = data_array[:, -1] cut = int(0.66 * len(X)) # Scale data to avoid network saturation X_train = X[:cut] X_test = X[cut:] scaler = StandardScaler() scaler.fit(X_train) X_train = scaler.transform(X_train) X_test = scaler.transform(X_test) mlp.fit(X_train, Y[:cut]) mlp_score = mlp.score(X_test, Y[cut:]) # Print results to screen frame.text.insert( INSERT, "Correlation Results:\nCast Facebook Likes & User Rating, Pearson: %.2f; Spearman: %.2f\n" "Budget and User Rating, Pearson: %.2f; Spearman: %.2f\n" "Runtime and User Rating, Pearson: %.2f; Spearman: %.2f\n" "Release Year and User Rating, Pearson: %.2f; Spearman: %.2f\n" "\nNeural Network R^2 Score: %.2f\n" "\n" % (p_fb_likes[0], s_fb_likes[0], p_budget[0], s_budget[0], p_runtime[0], s_runtime[0], p_release[0], s_release[0], mlp_score)) # Send plot of top revenue earning genre probability distributions to GUI frame.ax.scatter(release, user) frame.ax.set_title("Release Year vs. User Rating") frame.ax.set_xlabel('Release Year') frame.ax.set_ylabel('User Rating')
import quandl import pandas as pd from sklearn.neural_network import MLPRegressor from sklearn.model_selection import train_test_split from sklearn.tree import tree Data = pd.read_csv('infibeam.csv') x = Data.loc[:, 'High':'Turnover (Lacs)'] y = Data.loc[:, 'Open'] x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42) # DT=tree.DecisionTreeRegressor(random_state=42) MLP = MLPRegressor(random_state=42) MLP.fit(x_train, y_train) Test = [[2239.65, 230.35, 235.15, 234.9, 3357625.0, 7898.64]] Prediction = MLP.predict(Test) print(Prediction) print(MLP.score(x_test, y_test))
plt.rc('font', **font) fig, axes = plt.subplots(nrows=1, ncols=1) axes.set_title("Data: " + file) axes.set_ylabel('Normalized distant count') axes.set_xlabel('Distance ($\AA$)') axes.hist(y_train, 150, color='blue',normed=True, label='plot',linewidth=2,alpha=1.0) plt.show() """ # Fit model clf.fit(X_train, y_train) # Compute and print r^2 score print(clf.score(X_test, y_test)) # Store predicted energies Ecmp = clf.predict(X_test) Ecmp = gt.hatokcal * (Ecmp) Eact = gt.hatokcal * (y_test) # Compute RMSE in kcal/mol rmse = gt.calculaterootmeansqrerror(Ecmp, Eact) # End timer _t1e = tm.time() print("Computation complete. Time: " + "{:.4f}".format((_t1e - _t1b)) + "s") # Output model information
X_train_nn, X_test_nn, Y_train_nn, Y_test_nn = train_test_split( neural_network_df.ix[:, neural_network_df.columns != 'int_rate'], neural_network_df.int_rate, test_size=0.2) X_train_nn = StandardScaler().fit_transform(X_train_nn) X_test_nn = StandardScaler().fit_transform(X_test_nn) mlp = MLPRegressor(solver='lbfgs', hidden_layer_sizes=50, max_iter=150, shuffle=True, random_state=1) mlp.fit(X_train_nn, Y_train_nn) print("Training score is ", mlp.score(X_train_nn, Y_train_nn)) print("Testing score is ", mlp.score(X_test_nn, Y_test_nn)) # In[28]: from sklearn.neighbors import KNeighborsRegressor from sklearn.metrics import r2_score knn_df = df.copy() knn_df = knn_df[[ 'grade', 'total_pymnt_inv', 'revol_util', 'loan_status', 'fico_range_grade', 'total_rec_prncp', 'revol_bal', 'grade_based_on_inq_last_6mths', 'acc_open_past_24mths', 'installment', 'last_pymnt_amnt', 'funded_amnt_inv', 'total_acc', 'credit_age', 'issue_d', 'annual_inc', 'meanfico', 'int_rate' ]]
Y_tr = pheno[:1000,1:] #slicing pheno #Y_va = pheno[201:250,:] Y_te = pheno[1001:,1:] diabetes_X_train = X_tr diabetes_X_test = X_te diabetes_y_train = Y_tr diabetes_y_test = Y_te reg = MLPRegressor(hidden_layer_sizes=(1, ),algorithm='l-bfgs') reg.fit(X_tr,Y_tr) scores = cross_val_score(reg,geno[:,1:],pheno[:,1:],cv=10) #Result_Y = np.zeros((249,1), dtype='float64') Result_Y = reg.predict(X_te) #Yte = np.array(Y_te, dtype=np.float64) r_row,p_score = pearsonr(Result_Y,Y_te) # The mean square error print("Residual sum of squares: %.2f" % np.mean((reg.predict(diabetes_X_test) - diabetes_y_test) ** 2)) # Explained variance score: 1 is perfect prediction print('Variance score: %.2f' % reg.score(diabetes_X_test, diabetes_y_test)) print(Result_Y) print(scores) print(Result_Y.shape) print(r_row) print(p_score)
scaler = StandardScaler().fit(X_train) X_train = scaler.transform(X_train) X_test = scaler.transform(X_test) regr = MLPRegressor(max_iter=10, hidden_layer_sizes=(100, 50, 25, 10, 5), verbose=True) #### 8e changement : Parallélisme pour l'entrainement et la prédiction with joblib.parallel_backend('dask'): regr.fit(X_train, y_train) # Prédiction et Score with joblib.parallel_backend('dask'): score = regr.score(X_test, y_test) stop = datetime.now() print("Temps préparation et inférence (ML) : ", (stop - start).seconds, "s") print(f"model score: {score}") # %% [markdown] # Seul le training et le scale est parallélisé par Dask car le MLPRegressor n'a pas d'implémentation "Dask" # %% [markdown] # ## Entrainement et inférence avec pipeline # %% #### 6e changement : Utilisation d'un backend spécifique pour dask import joblib
K += 1 model = neighbors.KNeighborsRegressor(n_neighbors=K) model.fit(x_train, y_train) # fit the model pred = model.predict(x_test) # make prediction on test set error = sqrt(mean_squared_error(y_test, pred)) # calculate rmse rmse_val.append(error) # store rmse values curve = pd.DataFrame(rmse_val) # elbow curve plt.figure(figsize=(20, 5)) plt.plot(curve[1:]) plt.title('Elbow Curve').set_fontsize(16) plt.xlabel('K Value').set_fontsize(14) plt.ylabel('Root Mean Squared Error').set_fontsize(14) plt.show() knn = neighbors.KNeighborsRegressor(n_neighbors=12) mlp = MLPRegressor() regr = RandomForestRegressor(max_depth=2, random_state=0, n_estimators=100) knn.fit(x_train, y_train) mlp.fit(x_train, y_train) regr.fit(x_train, y_train) knn_score = knn.score(x_test, y_test) mlp_score = mlp.score(x_test, y_test) regr_score = regr.score(x_test, y_test) print([knn_score, mlp_score, regr_score])
from sklearn.linear_model import LinearRegression, SGDRegressor from sklearn.svm import SVR from sklearn.neural_network import MLPRegressor from sklearn.tree import DecisionTreeRegressor import pandas as pd from sklearn.model_selection import train_test_split df = pd.read_csv('Housing.csv') df.drop(['ID'], axis=1, inplace=True) from matplotlib import pyplot for i, column in enumerate(df.columns): pyplot.subplot(5, 3, i + 1) pyplot.scatter(df[column], df.iloc[:, -1]) pyplot.xlabel(column) pyplot.show() df = (df - df.mean()) / df.std() X = df.iloc[:, :-1] y = df.iloc[:, -1] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2) a = MLPRegressor() a.fit(X_train, y_train) print(a.score(X_test, y_test))
test_target = days_true #print(test_data) from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split from sklearn.neural_network import MLPRegressor scaler = StandardScaler() #X_train, X_test, y_train, y_test = train_test_split(train_data, train_target, test_size=0.20, random_state=0) #X_train_scaled = scaler.fit(X_train).transform(X_train) #X_test_scaled = scaler.fit(X_test).transform(X_test) train_data_scaled = scaler.fit_transform(train_data) test_data_scaled = scaler.fit_transform(test_data) mlp = MLPRegressor(max_iter=500, solver='lbfgs', hidden_layer_sizes=(5, 5), alpha=0.1, random_state=8) mlp.fit(train_data_scaled, train_target) print(mlp.score(train_data_scaled, train_target)) print(mlp.score(test_data_scaled, test_target)) pred_day = mlp.predict(test_data_scaled) print(test_target) print(pred_day.astype(int))
#Example with a Regressor using the scikit-learn library # example for the XOr gate from sklearn.neural_network import MLPRegressor X = [[0., 0.],[0., 1.], [1., 0.], [1., 1.]] # each one of the entries 00 01 10 11 y = [0, 1, 1, 0] # outputs for each one of the entries # check http://scikit-learn.org/dev/modules/generated/sklearn.neural_network.MLPRegressor.html#sklearn.neural_network.MLPRegressor #for more details reg = MLPRegressor(hidden_layer_sizes=(5),activation='tanh', algorithm='sgd', alpha=0.001, learning_rate='constant', max_iter=10000, random_state=None, verbose=False, warm_start=False, momentum=0.8, tol=10e-8, shuffle=False) reg.fit(X,y) outp = reg.predict([[0., 0.],[0., 1.], [1., 0.], [1., 1.]]) print'Results:' print '0 0 0:', outp[0] print '0 1 1:', outp[1] print '1 0 1:', outp[2] print '1 1 0:', outp[0] print'Score:', reg.score(X, y)
from __future__ import print_function, division from future.utils import iteritems from builtins import range, input # Note: you may need to update your version of future # sudo pip install -U future import numpy as np from sklearn.neural_network import MLPRegressor from util import getKaggleMNIST # get data X, _, Xt, _ = getKaggleMNIST() # create the model and train it model = MLPRegressor() model.fit(X, X) # test the model print("Train R^2:", model.score(X, X)) print("Test R^2:", model.score(Xt, Xt)) Xhat = model.predict(X) mse = ((Xhat - X)**2).mean() print("Train MSE:", mse) Xhat = model.predict(Xt) mse = ((Xhat - Xt)**2).mean() print("Test MSE:", mse)