ipt_closed = f.read() f.close() ipt_closed = ipt_closed.split("\n") for i in range(0, len(ipt_closed) - 1): ipt_closed[i] = ipt_closed[i].strip("[]").split(",") ipt_closed[i][0] = int(ipt_closed[i][0]) ipt_closed[i][1] = int(ipt_closed[i][1]) opt.append(0) ipt = ipt_open[:-1] + ipt_closed[:-1] ipt = np.asarray(ipt) opt = np.asarray(opt) print ":" + str(len(ipt)) print len(opt) nn = Classifier(layers=[ Layer("Softmax", units=2), Layer("Softmax", units=2), Layer("Softmax", units=2) ], learning_rate=0.05, n_iter=15) nn.fit(ipt, opt) a = np.asarray([[4, 30], [2, 30], [6, 300], [4, 300]]) # a =a.reshape(2,-1) op = nn.predict(a) print op
train[col] = le.transform(train[col]) test[col] = le.transform(test[col]) # Neural Network, Stochastic Gradient Descent is sensitive to feature scaling, # so it is highly recommended to scale your data. scaler = StandardScaler() for col in features_non_numeric: scaler.fit(list(train[col]) + list(test[col])) train[col] = scaler.transform(train[col]) test[col] = scaler.transform(test[col]) classifiers = [ xgb.XGBClassifier(gamma=10, max_depth=100, n_estimators=50000), Classifier( layers=[ Layer("Tanh", units=200), Layer("Sigmoid", units=200), Layer('Rectifier', units=200), Layer('Softmax')], learning_rate=0.05, learning_rule='sgd', learning_momentum=0.5, batch_size=100, valid_size=0.05, n_stable=100, n_iter=100, verbose=True) ] # Train for classifier in classifiers:
# Feature scaling min_max_scaler = preprocessing.MinMaxScaler() X_train = min_max_scaler.fit_transform(X_train) X_test = min_max_scaler.transform(X_test) X_signal = min_max_scaler.transform(X_signal) # Set target equal to input - replicator NN Y_train = X_train # NEURAL NETWORK TRAINING AND TESTING # Set up neural network if runTraining: print "Starting neural network training" nn = Regressor( layers=[Layer("Rectifier", units=30), Layer("Linear")], learning_rate=0.01, batch_size=100, #learning_rule = "momentum", n_iter=2000, valid_size=0.25) # Training nn.fit(X_train, Y_train) pickle.dump(nn, open('autoencoder.pkl', 'wb')) if not runTraining: nn = pickle.load(open('autoencoder.pkl', 'rb')) # Testing predicted_same = nn.predict(X_train) predicted_diff = nn.predict(X_test)
acc5 = 0 acc6 = 0 acc7 = 0 acc8 = 0 for i in range(5): # clf1 = MLPClassifier(hidden_layer_sizes=(k),early_stopping=True) # clf1.fit(Xnew,ytrain) # #arch 2: k/2 # clf2 = MLPClassifier(hidden_layer_sizes=(max((1,int(k/2)))),early_stopping=True) # clf2.fit(Xnew,ytrain) # #arch3: k/2, k/2 # clf3 = MLPClassifier(hidden_layer_sizes=(max((1,int(k/2))),max((1,int(k/2)))),early_stopping=True) # clf3.fit(Xnew,ytrain) clf1 = Classifier( layers=[Layer("Rectifier", units=k), Layer("Softmax")], regularize='L1', verbose=True, valid_size=0.1, n_iter=200) clf1.fit(Xnew, ytrain) #arch 2: k/2 clf2 = Classifier(layers=[ Layer("Rectifier", units=max((1, int(k / 2)))), Layer("Softmax") ], regularize='L1', verbose=True, valid_size=0.1, n_iter=200)
dep_data, test_size=.5, random_state=2016) Y_train = Y_train.as_matrix() Y_test = Y_test.as_matrix() X_trainn = preprocessing.normalize(X_train, norm='l2') X_testnn = preprocessing.normalize(X_test, norm='l2') X_trainn = preprocessing.scale(X_trainn) X_testnn = preprocessing.scale(X_testnn) #Build model clsfr = Classifier( layers=[ Layer("Rectifier", units=30), Layer("Rectifier", units=30), Layer("Softmax") ], learning_rate=.01, learning_rule='sgd', random_state=100, n_iter=T, # <---- Parameter being varied #learning_momentum=T, #valid_size=T, verbose=False) #Fit model model1 = clsfr.fit(X_trainn, Y_train) #Predictions y_hat = clsfr.predict(X_testnn)
from sknn.mlp import Classifier, Layer from sklearn import datasets import numpy as np import matplotlib.pyplot as plt import explore_results # Author: Mustafa Taha Kocyigit -- <*****@*****.**> nn = Classifier(layers=[Layer("Tanh", units=100), Layer("Softmax")], learning_rate=0.02, n_iter=10) # import some data to play with iris = datasets.load_iris() X = iris.data[:, :2] # we only take the first two features. Y = iris.target explore_results.plot_mash(nn, X, y)
# print "Cluster Array : " # print cluster_array m = max(cluster_array) index = 0 for l in range(0, cluster_size): if cluster_array[l] == m: index = l # print "Index Value : " + str(index) # MLP nn = Classifier(layers=[ Layer("Sigmoid", units=100), Layer("Softmax", name="OutputLayer", units=cluster_size) ], learning_rate=0.01, n_iter=100) nn.fit(X_Train, pred) pred_RBF = nn.predict(X_Test) for m in range(0, len(pred_RBF)): if pred_RBF[m] == index: pred_RBF[m] = 1 else: pred_RBF[m] = 0 acc_r = accuracy_score(Y_Test, pred_RBF)
from sknn.mlp import Classifier, Layer valid_errors = [] train_errors = [] def store_stats(avg_valid_error, avg_train_error, **_): valid_errors.append(avg_valid_error) train_errors.append(avg_train_error) from sklearn.model_selection import GridSearchCV nn = Classifier( layers=[ Layer('Sigmoid',dropout=0.20), Layer("Softmax")], valid_size=0.2, callback={'on_epoch_finish': store_stats}) gs = GridSearchCV(nn, param_grid={ 'n_iter': [100,500,1000], 'learning_rate': [0.01, 0.001], 'hidden0__units': [10, 20, 5], 'hidden0__type': ["Rectifier", "Sigmoid", "Tanh"]},refit=True) gs.fit(X_train,y_train) print(gs.best_estimator_) plt.figure() plt.plot(range(len(train_errors)),train_errors,color="b",label="training scores")
from sknn.mlp import Regressor from sknn.mlp import Layer import numpy as np import matplotlib.pyplot as plt # Design Network hiddenLayer = Layer("Rectifier", units=6) outputLayer = Layer("Linear", units=1) nn = Regressor([hiddenLayer, outputLayer], learning_rule='sgd', learning_rate=.001, batch_size=5, loss_type="mse") # Generate Data def cubic(x): return x**3 + x**2 - x - 1 def get_cubic_data(start, end, step_size): X = np.arange(start, end, step_size) X.shape = (len(X), 1) y = np.array([cubic(X[i]) for i in range(len(X))]) y.shape = (len(y), 1) return X, y # Train Model X, y = get_cubic_data(-2, 2, .1)
X_train, X_test, y_train, y_test = train_test_split( (mnist.data / 255.0).astype(np.float32), mnist.target.astype(np.int32), test_size=1.0/7.0, random_state=1234) classifiers = [] if 'sknn' in sys.argv: from sknn.platform import gpu32 from sknn.mlp import Classifier, Layer, Convolution clf = Classifier( layers=[ # Convolution("Rectifier", channels=10, pool_shape=(2,2), kernel_shape=(3, 3)), Layer('Rectifier', units=200), Layer('Softmax')], learning_rate=0.01, learning_rule='nesterov', learning_momentum=0.9, batch_size=300, valid_size=0.0, n_stable=10, n_iter=10, verbose=True) classifiers.append(('sknn.mlp', clf)) if 'nolearn' in sys.argv: from sknn.platform import gpu32 from nolearn.lasagne import NeuralNet, BatchIterator from lasagne.layers import InputLayer, DenseLayer
#============================Save pre-processed data=========================== data.to_csv('revised_data.csv', index=False) data = pd.read_csv('revised_data.csv') #============================================================================== def calculate_RMSE(predicted, actual): return math.sqrt(mean_squared_error(actual, predicted)) #===========================Neural Network Fitting============================= training_data = data.copy() training_data.drop('duration', 1, inplace=True) target_data = training_data.pop('size') #cross validation X_train, X_test, y_train, y_test = cross_validation.train_test_split( training_data.values, target_data.values, test_size=0.1, random_state=42) i = 0.1 neu_net_reg = Regressor(layers=[Layer("Sigmoid", units=30), Layer("Linear")], learning_rate=i, n_iter=19) neu_net_reg.fit(X_train, y_train) predicted_target_data = neu_net_reg.predict(X_test) print 'Learning rate: ' + str(i) + ' RMSE is: ' + str( calculate_RMSE(y_test, predicted_target_data)) #==============================================================================
melee = Melee() # gameState = [0 for i in acceptedInputs] # controllerState = [0 for i in acceptedOutputs] inputs = [] outputs = [] melee.listen(formattedReplay, lambda x, y: listener(x, y, inputs, outputs)) # with open(sys.argv[2], 'w') as outfile: # json.dump(inputs + outputs, outfile) nn = Regressor( layers=[ # Layer("Sigmoid",units=100), Layer("Sigmoid", units=200), Layer("Linear") ], learning_rate=0.02, n_iter=80) inScaler = StandardScaler() npin = np.array(inputs) inScaler.fit(npin) npout = np.array(outputs) # print(insc) # for i in inScaler.transform(npin): # print(i) nn.fit(inScaler.transform(npin), npout) pickle.dump((acceptedInputs, nn), open('nn4.pkl', 'wb')) # print(nn.predict(i for i in inputs[10]))
output.write("location,observation,prediction\n") for location in locations: trainX, testX, trainY, testY = splitDataForXValidation( location, "location", data, all_features, "target") normalizer_X = StandardScaler() trainX = normalizer_X.fit_transform(trainX) testX = normalizer_X.transform(testX) normalizer_Y = StandardScaler() trainY = normalizer_Y.fit_transform(trainY) testY = normalizer_Y.transform(testY) layers = [] for _ in range(0, parameters["hidden_layers"]): layers.append( Layer(parameters["hidden_type"], units=parameters["hidden_neurons"])) layers.append(Layer("Linear")) model = Regressor(layers=layers, learning_rate=parameters["learning_rate"], n_iter=parameters["iteration"], random_state=42) X = np.array(trainX) y = np.array(trainY) model.fit(X, y) model.fit(trainX, trainY) prediction = model.predict(testX) prediction = normalizer_Y.inverse_transform(prediction) testY = normalizer_Y.inverse_transform(testY)
lines = [line.split() for line in textFile] for line in lines: int_line = [float(x) for x in line] TrainData.append(int_line) TrainData = np.array(TrainData) with open(test_file_name) as textFile: lines = [line.split() for line in textFile] for line in lines: int_line = [float(x) for x in line] TestData.append(int_line) TestData = np.array(TestData) nn = Classifier(layers=[Layer("Sigmoid", units=100), Layer("Softmax")], learning_rate=0.02, n_iter=10) X_train = TrainData[:, 1:] y_train = TrainData[:, 0] new_y_train = np.zeros((len(X_train), len(Classes))) for i in range(0, len(TrainData)): new_y_train[i, int(y_train[i])] = 1 nn.fit(X_train, y_train) #y_valid = nn.predict(TestData[:,1:])
regline = plot.get_lines()[0] regline.set_color('red') R2_score_DF_RF_CV = r2_score(predict_DF_RF_CV["AC_cons"], predict_DF_RF_CV["AC_ConsPred_RF_CV"]) mean_absolute_error_DF_CV = mean_absolute_error( predict_DF_RF_CV["AC_cons"], predict_DF_RF_CV["AC_ConsPred_RF_CV"]) mean_squared_error_DF_CV = mean_squared_error( predict_DF_RF_CV["AC_cons"], predict_DF_RF_CV["AC_ConsPred_RF_CV"]) coeff_variation_DF_CV = np.sqrt( mean_squared_error_DF_CV) / predict_DF_RF_CV["AC_cons"].mean() from sknn.mlp import Regressor, Layer reg_NN = Regressor( layers=[ Layer("Rectifier", units=5), # Hidden Layer1 Layer("Rectifier", units=3), # Hidden Layer2 Layer("Linear") ], # Output Layer n_iter=100, learning_rate=0.02) reg_NN.fit(X_train_norm.as_matrix(), y_train_norm.as_matrix()) predict_DF_NN = reg_NN.predict(X_test_norm.as_matrix()) predict_DF_NN_CV = pd.DataFrame(predict_DF_NN, index=y_test_norm.index, columns=["AC_ConsPred_NN_CV"]) predict_DF_NN_CV = predict_DF_NN_CV.join(y_test_norm).dropna() predict_DF_NN_CV['2014-08-01':'2014-08-20'].plot() R2_score_DF_NN_CV = r2_score(predict_DF_NN_CV["AC_cons"],
def __init__(self, units=10): # trial 1 with 1 hidden layer layers_1 = [Layer('Rectifier', units=units), Layer("Softmax")] # trial 2 with 2 hidden layer layers_2 = [ Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer("Softmax") ] # trial 3 and so on.. layers_3 = [ Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer("Softmax") ] layers_4 = [ Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer("Softmax") ] layers_5 = [ Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer("Softmax") ] layers_6 = [ Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer("Softmax") ] layers_7 = [ Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer("Softmax") ] layers_8 = [ Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer("Softmax") ] layers_9 = [ Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer("Softmax") ] layers_10 = [ Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer('Rectifier', units=units), Layer("Softmax") ] self.layers_list = [ layers_1, layers_2, layers_3, layers_4, layers_5, layers_6, layers_7, layers_8, layers_9, layers_10 ]
continue nameFileImage = "{0}{1}{2}".format(fileNameDir[0], os.sep, fileName) image = imread(nameFileImage, as_grey=True) image = resize(image, (pix, pix)) # Resizing is done image = np.array(image, dtype=np.float) image = np.reshape(image, (1, pix ** 2)) X[i, 0:pix * pix] = image y[i] = label i += 1 label += 1 print("Progress: ", label, " of 121") # Fitting a convoluted neural network print("Start fitting convoluted NN") layer_1 = Convolution("Tanh", channels= 6, kernel_shape= (1,3)) layer_out = Layer("Softmax") lay = [layer_1, layer_out] nn = Classifier(layers= lay, learning_rate= 0.001, n_iter= 2) print("Start fitting NN") nn.fit(X= X, y= y) print("Fineshed fitting") # Saving the NN pickle.dump(nn, open("Convoluted.pk1", "wb")) # ----------------------------------------------------------------------------------------------------------- # # Estimating the generalisation error with CV: all classes indivudually and multiclass log-loss print("CV for class-wise generalisation errors") num_folds = 2
filename = 'NN_' + sys.argv[1][:sys.argv[1].rfind('.')] for i in range(2, len(sys.argv)): filename = filename + '_' + sys.argv[i] filename = filename + '.txt' sys.stdout = Logger(filename) #Seperate features from labels X_data = _data[:, range(0, _data.shape[1] - 1)] y_data = _data[:, _data.shape[1] - 1] #Set random_state=0 for testing X_train, X_test, y_train, y_test, i_train, i_test = train_test_split( X_data, y_data, range(0, len(y_data)), test_size=0.20) classifier = Classifier( layers=[Layer("Sigmoid", units=int(sys.argv[4])), Layer("Softmax")], learning_rate=float(sys.argv[2]), n_iter=int(sys.argv[3])) classifier.fit(X_train, y_train) old_stdout = sys.stdout sys.stdout = open(os.devnull, 'w') results = classifier.predict(X_test) #May produce junk output results_proba = classifier.predict_proba(X_test) #May produce junk output sys.stdout.close() sys.stdout = old_stdout results = np.reshape(results, (results.shape[0], 1)) results_proba = np.reshape(results_proba, (results.shape[0], 2))
from sknn.mlp import Classifier, Layer nn = Classifier(layers=[Layer("Rectifier", units=100), Layer("Softmax")], learning_rate=0.02, n_iter=10) nn.fit(X_train, y_train) y_valid = nn.predict(X_valid) score = nn.score(X_test, y_test)
pickle.dump(nn, open(path, 'w')) nn.n_iter = n_epoch % save_part nn.fit(X_train, Y_train) pickle.dump(nn, open(path, 'w')) N = 100 X, Y = create_ds(N) print X.shape, '--', Y.shape print X[:5] print Y[:5] print '___________' nn = Regressor( layers=[ #Convolution("Rectifier",channels=1,kernel_shape=(1,1)), Layer("Rectifier", units=128), Layer("Rectifier", units=128), Layer("Linear", units=64), Layer("Tanh") ], learning_rate=0.01, verbose=True) train(nn, X, Y, './mod_prim', 2, 2) print "#-----TESTING-----#" nn = pickle.load(open('./mod_prim', 'r')) test = create_ds(2 * N) pred = nn.predict(test) for i, p in enumerate(pred): #plt.imshow(test[i]) #plt.show()
trI=trI.astype('float'); teI=teI.astype('float'); if (useHOG==False): trI/=255.0; teI/=255.0; #print trI[0]; #print trI, trL; #print teI, teL; nn = Classifier( layers=[ Layer("Rectifier", units=800), Layer("Rectifier", units=400), #Layer("Rectifier", units=200), Layer("Softmax")], learning_rate=0.015, dropout_rate=0.35, valid_size=0.15, learning_momentum=0.4, batch_size=20, #learning_rule='adam', n_iter=100, verbose=True) nn.fit(trI,trL);
if outliers: print X.shape, y.shape clf = LocalOutlierFactor(n_neighbors=20) Xlog = clf.fit_predict(X, y) print X.shape, y.shape, Xlog.shape y = y[Xlog == 1] X = X[Xlog == 1] print X.shape, y.shape, Xlog.shape random_state = random.randint(1e3, 1e6) if method == 'nn': classifier = Pipeline([('neural network', Classifier(layers=[ Layer('Linear', name='hidden0', units=5), Layer('Rectifier', name='hidden1', units=3), Layer('Linear', name='hidden2', units=5), Layer('Softmax', units=2) ], learning_rate=0.004095, n_iter=100))]) elif method == 'svc': classifier = svm.SVC(kernel='sigmoid', probability=True, random_state=random_state, verbose=False) elif method == 'svr': classifier = svm.SVR(kernel='rbf', verbose=False, cache_size=1000) elif method == 'nnreg':
# Split data as training-set and test-set X_train, X_test, y_train, y_test = tts(X, y, test_size=0.4, random_state=0) X_cross, X_test, y_cross, y_test = tts(X_test, y_test, test_size=0.5, random_state=0) print(y_train.shape) print(y_test.shape) print(y_cross.shape) # build multiple layers perceptron classifier layer1 = Layer("Rectifier", units=45, weight_decay=0.001) layer2 = Layer("Rectifier", units=30, weight_decay=0.001) layer3 = Layer("Softmax") cls = Classifier(layers=[layer1, layer2, layer3], learning_rule="adam", learning_rate=0.003, f_stable=0.01, debug=True, batch_size=200, n_iter=100) cls.fit(X_train, y_train) # get the probability of prediction for cross data y_predict = cls.predict_proba(X_cross, collapse=True)
import numpy as np import csv train = pd.read_hdf("train.h5", "train") test = pd.read_hdf("test.h5", "test") print "Creating data\n" # Grab the correct indices from the training data X = train.ix[:, 1:101].as_matrix() y = train.ix[:, 0:1].as_matrix() from sknn.mlp import Classifier, Layer # This is the important stuff to adjust print "Creating classifier\n" nn = Classifier(layers=[ Layer('Tanh', units=100), Layer('Sigmoid', units=25), Layer('Softmax', units=5) ], learning_rate=.03, n_iter=73, batch_size=10) """ Uncomment to actually train whole data and write file """ outfile = open('output.csv', 'w') # change the file name writer = csv.writer(outfile) writer.writerow(['Id', 'y']) print "About to fit\n" nn.fit(X, y) print "About to predict"
le = LabelEncoder() for col in features_non_numeric: le.fit(list(train[col])+list(test[col])) train[col] = le.transform(train[col]) test[col] = le.transform(test[col]) # Neural Network, Stochastic Gradient Descent is sensitive to feature scaling, so it is highly recommended to scale your data. scaler = StandardScaler() for col in features: scaler.fit(list(train[col])+list(test[col])) train[col] = scaler.transform(train[col]) test[col] = scaler.transform(test[col]) MyNNClassifier = Classifier( layers=[ Layer("Tanh", units=100), Layer("Tanh", units=100), Layer("Tanh", units=100), Layer("Sigmoid", units=100), Layer('Softmax')], learning_rate=0.01, learning_rule='momentum', learning_momentum=0.9, batch_size=100, valid_size=0.01, n_stable=20, n_iter=200, verbose=True) # Define classifiers if sample:
iteration = 25 #25 learning_rate = 0.001 #0.001 units = [5,10,15,20,25,30] # load data X_train, X_test, y_train, y_test = load_data(test_size=test_size) # arrays for storing results scores_train = [[] for i in range(num_of_trials)] scores_test = [[] for i in range(num_of_trials)] for n in range(num_of_trials): print('============== Trial: {} ==============='.format(n+1)) for i, unit in enumerate(units): clf = Classifier( layers=[ Layer('Rectifier', units=unit), Layer("Softmax")], learning_rate=learning_rate, n_iter=iteration) clf.fit(X_train, y_train) print ('====================================') scores_train[n].append(clf.score(X_train, y_train)) scores_test[n].append(clf.score(X_test, y_test)) print ('num of units >> {}'.format(unit)) print (' - Training set score: {}'.format(scores_train[n][i])) print (' - Test set score: {}'.format(scores_test[n][i])) scores_train = np.array(scores_train) scores_test = np.array(scores_test)
def training(feat, labelfile, cls): # feat=feat.reshape((-1,100)) # feat.dump('featureVector.txt') f = open(labelfile, 'r') labels = list(f.read()) f.close() from random import shuffle ind_list = [i for i in range(len(labels))] shuffle(ind_list) f = feat[ind_list] l = [labels[i] for i in ind_list] feat = f labels = l print(feat[1], labels[1]) if cls == 'KNN': from sklearn.neighbors import KNeighborsClassifier clf = KNeighborsClassifier(n_neighbors=11) # feats=feats.reshape(-1,40*40) clf.fit(feat, labels) from sklearn.externals import joblib joblib.dump(clf, 'clsfKNN.pkl') elif cls == 'CNN': from sklearn.neural_network import MLPClassifier X = feat / 255.0 X = X.reshape(-1, 40, 40) y = np.array(labels) y = y.reshape(-1, 1) from sknn.mlp import Classifier, Convolution, Layer clf = Classifier(layers=[ Convolution("Rectifier", channels=89, kernel_shape=(3, 3)), Layer("Softmax") ], learning_rate=0.02, n_iter=25) clf.fit(X, y) from sklearn.externals import joblib joblib.dump(clf, 'clsfCNN.pkl') elif cls == 'SVM': from sklearn import svm clf = svm.SVC() X, y = feat, labels clf.fit(X, y) from sklearn.externals import joblib joblib.dump(clf, 'clsfSVM.pkl') elif cls == 'TREE': from sklearn import tree clf = tree.DecisionTreeClassifier() clf = clf.fit(feat, labels) from sklearn.externals import joblib joblib.dump(clf, 'clsfTREE.pkl') elif cls == 'NB': from sklearn.naive_bayes import MultinomialNB clf = MultinomialNB() clf.fit(feat, labels) from sklearn.externals import joblib joblib.dump(clf, 'clsfNB.pkl')
# importance = bst.get_fscore() # 特征的重要性 # plot_importance(bst) # pyplot.show() pre_label = bst.predict(xgbtest) loss = t-pre_label MAPE = (sum(abs(loss)/t))/len(t) mapeSet.append(MAPE) para.append([inn,im,ie]) count=count+1 print('---> ',count,'......') # scikit-neuralnetwork for regression(有问题,无法训练) if 0: mlp = Regressor(layers=[Layer('Rectifier',units=100,weight_decay=0.0001,dropout=0.5),Layer('Linear')],learning_rule='sgd', learning_rate=0.01, batch_size=500, n_iter=10,loss_type = 'mse') mlp.fit(X,y) pre_label = mlp.predict(T) ''' # %% # plot loss = t-pre_label # 误差 Z = np.zeros([len(loss)]) plt.plot(loss,'g') plt.plot(Z,'r') plt.xlabel('Number of the sample') plt.ylabel('loss(s)') plt.title('Visualizing loss') plt.show()
# We create the optimizer object opt = pysmac.SMAC_optimizer(working_directory='./results/dataset6/smac/' % os.environ, persistent_files=True, debug=False) # First we try the a MLP set to a default configuration, so we can see if SMAC can improve its performance scores = [] for i in np.arange(n_validations): X_train, X_test, Y_train, Y_test = sklearn.cross_validation.train_test_split( X, Y, test_size=0.3, random_state=1) predictor = Classifier(layers=[ Layer("Sigmoid", units=100, dropout=0), Layer("Sigmoid", units=100, dropout=0), Layer("Softmax", units=2) ], learning_rate=0.001, n_iter=25) predictor.fit(X_train, Y_train) scores.append(metrics.accuracy_score(Y_test, predictor.predict(X_test))) print(('The default accuracy is %f' % median(scores))) # We set some parameters for the optimizer value, parameters = opt.minimize( mlp, n_iter, parameter_definition, # number of evaluations
def plotation(clf_list): nlines = len(clf_list) plt.figure(figsize=(20, 10 * nlines)) cm = plt.cm.RdBu cm_bright = ListedColormap(['#FF0000', '#0000FF']) X_train_plot = np.transpose([np.transpose(X_train)[i] for i in (4, 5)]) Nlvl = 5 c = 1 mlp_Reg_type = type( Regressor(layers=[Layer("Rectifier", name="hiddenN")], learning_rate=0.02, n_iter=10)) mlp_Cla_type = type( Classifier(layers=[Layer("Rectifier", name="hiddenN")], learning_rate=0.02, n_iter=10)) robust_scaler = False for _, clf in enumerate(clf_list): if hasattr(clf, "predict_proba"): print("Classifieur") if type(clf) == mlp_Cla_type: robust_scaler = sklearn.preprocessing.RobustScaler() X_train_plot_scaled = robust_scaler.fit_transform(X_train_plot) clfY = clf.fit(X_train_plot_scaled, into_levels(Y_train, Nlvl)) clfZ = clf.fit(X_train_plot_scaled, into_levels(Z_train, Nlvl)) else: clfY = clf.fit(X_train_plot, into_levels(Y_train, Nlvl)) clfZ = clf.fit(X_train_plot, into_levels(Z_train, Nlvl)) else: print("Regresseur") if type(clf) == mlp_Reg_type: robust_scaler = sklearn.preprocessing.RobustScaler() X_train_plot_scaled = robust_scaler.fit_transform(X_train_plot) clfY = clf.fit(X_train_plot_scaled, Y_train) clfZ = clf.fit(X_train_plot_scaled, Z_train) else: clfY = clf.fit(X_train_plot, Y_train) clfZ = clf.fit(X_train_plot, Z_train) for _, clfdata in enumerate([clfY, clfZ]): axes = plt.subplot(nlines, 2, c) m = Basemap(llcrnrlon=x_min, llcrnrlat=y_min, urcrnrlon=x_max, urcrnrlat=y_max, resolution='i', projection='cass', lon_0=-74.00597, lat_0=40.71427, ax=axes) m.drawcoastlines() lons, lats = m.makegrid(100, 100) x, y = m(lons, lats) Z = np.zeros((100, 100)) for l in range(100): for p in range(100): LP = np.array([lons[l][p], lats[l][p]]) LP = np.array([LP]) if robust_scaler != False: LP = robust_scaler.transform(LP) Z[l][p] = clfdata.predict(LP) diff = np.max(Z) - np.min(Z) cs = m.contourf( x, y, Z, [np.min(Z) + diff * i / Nlvl for i in range(0, Nlvl + 1)], cmap=cm, alpha=.8) m.colorbar(cs, location='bottom', pad="5%") c += 1 robust_scaler = False