#------------- Defining the environnement -----------
environnement = Environnement(N_items, N_recommended, behaviour, rewardType,
rewardParameters)
#>>> let's test the efficiency of our algorithm by testing with this simplified set:
for item in environnement.items.items:
item.cost = 1
environnement.items.items[2].cost = 0
environnement.items.items[4].cost = 0
#<<<
environnement.items.display(True)
# >>> Grid search over the parameters to get the best parameters
gridSearch = GridSearch()
num_avg = 3
_, params = gridSearch(num_avg,
environnement,
memory,
choiceMethod,
epochs,
train_list,
steps=steps)
#------------ launching the episode series : Average the learning processes results ---------------
#(less randomness in the plots), for statistical study, than the Series class
num_avg = 5
avgSeries = AverageSeries(num_avg, environnement, memory, choiceMethod, params,
epochs, train_list, steps)
Rewards = avgSeries.avgRewards
def results_on_same_environnement():
# ______ Environment creation _________
environnement = Environnement(N_items,
N_recommended,
behaviour,
rewardType,
rewardParameters,
proba_p=min_similarities_sum)
environnement.items.items[0].cost = 0 # To remove later
# ______ RL agents ____________________
# a) DeepQlearning
# --params --
choiceMethod = 'DeepQlearning'
model = nn.Sequential(nn.Linear(memory + 2 * N_recommended, 10), nn.SELU(),
nn.Linear(10, 1))
trainable_layers = [0, 2]
deepQModel = {'model': model, 'trainable_layers': trainable_layers}
# -- Grid search the best parameters --
gridSearch = GridSearch()
_, params = gridSearch(num_avg,
environnement,
memory,
choiceMethod,
epochs,
train_list,
steps=steps,
more_params=None,
deepQModel=deepQModel)
# -- Results with the best hyper parameters --
avgSeries_DL = AverageSeries(num_avg, environnement, memory, choiceMethod,
params, epochs_test, train_list, steps,
deepQModel)
Rewards_DeepQLearning = avgSeries_DL.avgRewards
# b) Tabular Q Learning
# --params --
choiceMethod = 'QlearningActionsTuples'
# -- Grid search the best parameters --
gridSearch = GridSearch()
_, params = gridSearch(num_avg,
environnement,
memory,
choiceMethod,
epochs,
train_list,
steps=steps)
# -- Results with the best hyper parameters --
avgSeries_Tabular = AverageSeries(num_avg, environnement, memory,
choiceMethod, params, epochs_test,
train_list, steps)
Rewards_Tabular = avgSeries_Tabular.avgRewards
# c) Linear Q Learning
# --params --
choiceMethod = 'LinearQlearning'
# -- Grid search the best parameters --
gridSearch = GridSearch()
_, params = gridSearch(num_avg,
environnement,
memory,
choiceMethod,
epochs,
train_list,
steps=steps)
# -- Results with the best hyper parameters --
avgSeries_Linear = AverageSeries(num_avg, environnement, memory,
choiceMethod, params, epochs_test,
train_list, steps)
Rewards_Linear = avgSeries_Linear.avgRewards
return np.array(Rewards_Tabular), np.array(
Rewards_DeepQLearning), np.array(Rewards_Linear)
if config.stream == "s":
ser_loop = threading.Thread(target=serial_loop, name="ser_loop", args=())
ser_loop.setDaemon(True)
ser_loop.start()
elif config.stream == "t" and config.face_or_words == "words":
for i in range(50, 300):
config.length_array = i
print(i)
if config.learner == "na":
na.setup()
elif config.learner == "svm":
svm.setup()
elif config.stream == "g":
gd.start()
else:
if config.learner == "svm":
learner = svm
else:
learner = na
machine = learner.setup()
def main():
while True:
console_input = input()
if console_input == "s":
config.is_input_word = True
elif console_input == "e":
config.is_input_word = False
def main(filename, n_folds, useWord, sampleSize, reducedDim, opt, n_class,
kernel, vecName, gridsearch):
if vecName == "new":
iter_flag = True
# trainingData & trainingLabels 作成
print "opt :", opt
if opt == "equal":
while iter_flag:
training_data, training_labels = createTrainingVec_Equal(
filename, useWord, sampleSize, n_class)
if len(training_labels) > 1:
iter_flag = False
elif opt == "hist":
while iter_flag:
try:
training_data, training_labels, vplace_lists = createTrainingVec_Equal_Hist(
filename, useWord, sampleSize, n_class, opt)
except:
continue
if len(training_labels) > 1:
iter_flag = False
elif opt == "hist_all":
while iter_flag:
try:
training_data, training_labels, vplace_lists = createTrainingVec_Equal_Hist(
filename, useWord, sampleSize, n_class, opt)
except:
continue
if len(training_labels) > 1:
iter_flag = False
else:
training_data, training_labels = createTrainingVec(
filename, useWord, sampleSize)
print "sample size :", len(training_labels)
# for x in training_labels:
# print x
# return True
# PCAを用いた次元削減
training_data = DimensionReduction(filename, training_data, reducedDim)
np.savetxt("data/v20000rd100nc100_data.csv",
training_data,
delimiter=",")
np.savetxt("data/v20000rd100nc100_labels.csv",
training_labels,
delimiter=",")
elif vecName == "v20000rd100nc100":
training_data = np.loadtxt("data/v20000rd100nc100_data.csv",
delimiter=",")
training_labels = np.loadtxt("data/v20000rd100nc100_labels.csv",
delimiter=",")
if gridsearch:
print "GridSearch starts"
GridSearch.Gridsearch(training_data, training_labels)
else:
# K-分割交差検証
kfold = cross_validation.KFold(len(training_data), n_folds=n_folds)
results = np.array([])
confirmation = []
counter = 0
for training, test in kfold:
counter += 1
print counter, "folds ",
# 教師データで SVM を学習する
clf = svm.SVC(kernel=kernel)
clf.fit(training_data[training], training_labels[training])
# テストデータを使った検証
answers = clf.predict(training_data[test])
# ラベルデータと一致しているか調べる
are_correct = answers == training_labels[test]
results = np.r_[results, are_correct]
pre = np.c_[answers, training_labels[test]]
confirmation.append(pre)
print ""
print('カーネル: {kernel}'.format(kernel=kernel))
correct = np.sum(results)
N = len(training_data)
percent = (float(correct) / N) * 100
print('正答率: {percent:.2f}% ({correct}/{all})'.format(
correct=correct,
all=len(training_data),
percent=percent,
))
if "hist" in opt:
for i, x in enumerate(vplace_lists):
vplace_lists[i] = int(
float(useWord) * 100 / float(vplace_lists[i]))
vplace_lists_corr = np.zeros(len(vplace_lists))
for i, x in enumerate(results):
if x == 1:
vplace_lists_corr[i] = vplace_lists[i]
vplace_lists_corr.sort()
while True:
vplace_lists_corr = np.delete(vplace_lists_corr, 0)
if vplace_lists_corr[0] > 0:
break
Histogram.Histogram(filename, vplace_lists, vplace_lists_corr)
# print results
# print "prediction, correct"
# for x in confirmation:
# for y in x:
# print y[0], "\t", y[1]
joblib.dump(
clf, 'data/SVM/SVM_' + filename + '_' + str(n_folds) + 'folds' +
'_clf_' + kernel + '_rd' + str(reducedDim) + '_nClass' + str(n_class))
"""Splitting of test-/train data and testing with different models"""
# x_train, x_test, y_train, y_test = sklearn.model_selection.train_test_split(x, y, test_size=0.33, train_size=0.67,
# random_state=88, shuffle=True)
#
# knn = sklearn.neighbors.KNeighborsClassifier(n_neighbors=2, weights='distance', algorithm='auto', p=5)
# knn.fit(x_train, y_train)
# cross_val_score = sklearn.model_selection.cross_val_score(knn, x_train, y_train, cv=100)
# print("KNN Accuray: {}%".format(float('%.3f' % (cross_val_score.mean()*100))))
"""GridSearch for different Parameters"""
svc_c = [0.01, 0.1, 1, 5, 10, 50, 100, 250, 500, 1000, 2500]
svc_gamma = [100, 50, 10, 5, 1, 0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001]
svc_kernel = ['rbf', 'linear', 'sigmoid']
gs = GridSearch.GridSearch(grid_size=len(svc_c),
cv=10,
features=x,
target=y,
cross_validated=True)
grid = gs.svc_clf_gs(c_list=svc_c, gamma_list=svc_gamma, kernel=svc_kernel[0])
print(grid)
gs.heatmap(y_axis=svc_c,
x_axis=svc_gamma,
grid_values=grid,
cmap_color='Wistia')
"""Chosen models for prediction, which is saved as pickles"""
# # Accuracy value: ~0.96
# # Kernel: rbf, gamma: 0.0001, C: 100
#
# classifier = sklearn.svm.SVC(C=100, gamma=0.0001, kernel='rbf').fit(x_train, y_train)
# pickle.dump(classifier, open('E:/Schule/2. Halbjahr/Wahlpflicht/Projekt2/Model/finalized_model.sav', 'wb'))
