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
