def test_keras_regressor():
model = Sequential()
model.add(Dense(input_dim, input_shape=(input_dim,)))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('softmax'))
sklearn_regressor = KerasRegressor(model, optimizer=optim, loss=loss,
train_batch_size=batch_size,
test_batch_size=batch_size,
nb_epoch=nb_epoch)
sklearn_regressor.fit(X_train_reg, y_train_reg)
sklearn_regressor.score(X_test_reg, y_test_reg)
def _read_loto_result():
_df_loto = pd.read_csv('C:\\Users\\hal\\Downloads\\loto6.csv',
sep=",",
encoding='shift_jis')
#print(_df_loto)
x_train, x_test, y_train, y_test = model_selection.train_test_split(
X, Y, test_size=0.2)
return
for a_i in range(1, 2):
a_num_str = '第' + str(a_i) + '数字'
# 過去の当選結果の抽出
_df_loto_sub = _df_loto[['日付', a_num_str]]
print(_df_loto_sub)
#plt.plot(_df_loto_sub)
#plt.show()
########################################
# 欠損データの削除
########################################
#_df_loto_sub = _df_loto_sub.dropna()
########################################
# One-hotエンコーディング
########################################
########################################
# 学習
########################################
X = _df_loto_sub['日付']
Y = _df_loto_sub[a_num_str]
x_train, x_test, y_train, y_test = model_selection.train_test_split(
X, Y, test_size=0.2)
# 正規化
scaler = StandardScaler()
scaler.fit(x_train)
x_train = scaler.transform(x_train)
x_test = scaler.transform(x_test)
########################################
# Keras読込
########################################
# モデルの取得
model = KerasRegressor(build_fn=reg_model,
epochs=200,
batch_size=16,
verbose=0)
# 学習
model.fit(x_train, y_train)
# スコア（参考値）
model.score(x_test, y_test)
def runANN(inputs, hp):
if inputs:
data = pickle.loads(inputs)
else:
data = build_dataset()
ts = datetime.datetime.now()
outputs = []
for l1_units, l2_units in hp:
model = KerasRegressor(build_fn=create_baseline_model,
l1_units=l1_units,
l2_units=l2_units,
verbose=0)
model.fit(data["x_train"],
data["y_train"],
verbose=0,
validation_data=(data["x_val"], data["y_val"]),
epochs=300)
score = model.score(data["x_val"], data["y_val"])
preds = model.predict(data["x_test"])
pred = preds.reshape(len(preds))
real = data["y_test"]
mse = mean_squared_error(real, pred)
output = {}
output['score'] = score
output['mse'] = mse
output['hp'] = [l1_units, l2_units]
outputs.append(output)
ts = datetime.datetime.now() - ts
h = socket.gethostname()
return {
"msg": "Run ANN! [" + h + "] > elapsed time: " + str(ts),
"data": outputs,
}
def test_regression_model(build_fn, modle_name, num_repeats=10):
# NOTE!
# The negative MSE might be confusing, but it depends a bit what parts of sklearn you use
# https://github.com/scikit-learn/scikit-learn/issues/2439
# So the closer to Zero the MSE, the better
# For regression, see e.g.
# https://stackoverflow.com/questions/44132652/keras-how-to-perform-a-prediction-using-kerasregressor
seed(MJTCP_SEED)
results = np.zeros(num_repeats)
acc = np.zeros(num_repeats)
results_cv = np.zeros(num_repeats)
for i in range(num_repeats):
print('Repeat #', i+1, '/', num_repeats)
reg = KerasRegressor(build_fn=build_fn, epochs=100, batch_size=10, verbose=0)
reg.fit(x_train, y_train)
# prediction = reg.predict(x_train)
# acc[i] = accuracy_score(y_test, prediction) # TODO!
results[i] = reg.score(x_test, y_test)
print(' MSE (no cross-validation) = ', results[i])
# n_splits = 10
# kfold = KFold(n_splits=10, random_state=seed)
# results_cv[i] = cross_val_score(reg, x_train, y_train, cv=kfold)
# print(' MSE (cross-validation, ', n_splits, ' splits) = ', results_cv[i])
# # print(' Accuracy = ', acc[i])
# sys.stdout.flush()
print("\n%s: Mean of MSE from %i repeats: %.2f (stdev = %.2f)" % (
modle_name, num_repeats, results.mean(), results.std()))
# print("%s: Mean of MSE with cross validation from %i repeats: %.2f (stdev = %.2f)" % (
# modle_name, num_repeats, results_cv.mean(), results_cv.std()))
# print("%s: Mean Accuracy from %i repeats: %.2f (stdev = %.2f)" % (
# modle_name, num_repeats, acc.mean(), acc.std()))
return results.mean()
scaler = StandardScaler()
x_train = scaler.fit_transform(x_train)
x_valid = scaler.transform(x_valid)
x_test = scaler.transform(x_test)
x_new = x_test[:3]
def build_model(n_hidden=1, n_neurons=30, learning_rate=3e-3, input_shape=[8]):
model = Sequential()
model.add(InputLayer(input_shape=input_shape))
for layer in range(n_hidden):
model.add(Dense(n_neurons, activation='relu'))
model.add(Dense(1))
optimizer = SGD(lr=learning_rate)
model.compile(loss='mse',optimizer=optimizer)
return model
keras_reg = KerasRegressor(build_model)
keras_reg.fit(x_train,y_train,epochs=100,
validation_data=(x_valid,y_valid),
callbacks=[EarlyStopping(patience=10)])
mse_test = keras_reg.score(x_test,y_test)
y_pred = keras_reg.predict(x_new)
print(y_pred)
def run_regressor(model=LSTM2,
sequence_length=SEQ_LENGTH,
data=None,
data_file='df_dh.csv',
isload_model=True,
testonly=False):
epochs = 20000
path_to_dataset = data_file
global mses
if data is None:
X_train, y_train, X_test, y_test, X_val, Y_val = get_data(
sequence_length=sequence_length,
stateful=STATEFUL,
path_to_dataset=data_file)
else:
X_train, y_train, X_test, y_test, X_val, Y_val = data
if STATEFUL:
X_test = X_test[:int(X_test.shape[0] / batch_size) * batch_size]
y_test = y_test[:int(y_test.shape[0] / batch_size) * batch_size]
estimator = KerasRegressor(build_fn=lambda x=X_train: model(x))
# if testonly == True:
# # predicted = model.predict(X_test, verbose=1,batch_size=batch_size)
# prediction = estimator.predict(X_test)
# stat_metrics(X_test, y_test, prediction)
# draw_scatter(predicted_arr[0], y_test, X_test, X_train, y_train, data_file)
# return
early_stopping = EarlyStopping(monitor='val_loss', verbose=1, patience=40)
checkpoint = ModelCheckpoint("./lstm.h5",
monitor='val_loss',
verbose=1,
save_best_only=True,
save_weights_only=True)
################
hist = estimator.fit(X_train,
y_train,
validation_data=(X_val, Y_val),
callbacks=[checkpoint],
epochs=epochs,
batch_size=batch_size,
verbose=1)
# prediction = estimator.predict(X_test)
score = mean_squared_error(y_test, estimator.predict(X_test))
estimator_score = estimator.score(X_test, y_test)
print(score)
mses.append(score)
prediction = estimator.predict(X_test)
print(prediction)
print(X_test)
print("##############################################")
# predicted_arr = prediction.T.tolist()
# print(predicted_arr)
global scaler
prediction_, y_test_, y_train_ = inverse_xy_transform(
scaler, prediction, y_test, y_train)
predicted_df = pd.DataFrame(prediction_)
y_test_df = pd.DataFrame(y_test_)
# X_test_df = pd.DataFrame(X_test) #columns
predicted_df.to_csv(DATAPATH + str(prefix) + data_file + str(batch_size) +
str(sequence_length) + "predicted_df.csv")
y_test_df.to_csv(DATAPATH + str(prefix) + data_file + str(batch_size) +
str(sequence_length) + "y_test_df.csv")
# X_test_df.to_csv(DATAPATH+data_file+"X_test_df.csv")
draw_scatter(prediction, y_test, X_test, X_train, y_train, data_file)
his_figures(hist)
draw_line(prediction, y_test, X_test, X_train, y_train, data_file)
return predicted_df, y_test_df
def EvaluateModel(params):
global MOD_TYPE
global INPUT_SHAPE
# Get the Train/Test data... depending on the various parameters,
XTrain, YTrain, XTestIDs, XTestValues = HousingDataUtils.GetTrainTestData(
CatEncoding=params[1],
ScalingType=params[2],
LogSalesPrice=params[3],
DropLilVarFeats=params[4],
DropLilCorrFeats=params[5],
MakeNewFeatures=params[6],
DropUsedFeatures=params[7],
DropOutliers=params[8])
#XTrain_split, XValid, YTrain_split, YValid = train_test_split (XTrain, YTrain, random_state=42)
# Make the model...
print('\n>>> Building and Fitting Model...')
MOD_TYPE = params[0]
INPUT_SHAPE = XTrain.shape[1:]
cb = tf.keras.callbacks.EarlyStopping(monitor='loss', patience=PATIENCE)
model = KerasRegressor(build_fn=BuildModel,
validation_split=0.2,
epochs=MAX_EPOCHS,
verbose=2,
callbacks=[cb])
history = model.fit(XTrain, YTrain)
# get the model score... or loss and mean square error
modelScore = model.score(XTrain, YTrain)
print('>>> modelScore = ', modelScore)
print()
# feature importance...
print('>>> Finding feature importance...')
featImportanceResults = HousingDataUtils.FindFeatureImportance(
model, XTrain, YTrain, 3, 100)
for i in range(len(featImportanceResults)):
print(
f'{featImportanceResults[i][0]:25} {featImportanceResults[i][1]:14.7f} {featImportanceResults[i][2]:14.7f}'
)
# Predict the model
print('Predicting the model...')
predYValues = model.predict(XTestValues).tolist()
# output...
outputFile = MakeOutputFileName(params)
print('>>>Writing output to...', outputFile)
results, errMsg = HousingDataUtils.MergeResult(XTestIDs, predYValues,
params[3], YTrain.mean())
results.to_csv(outputFile, index=False)
if errMsg != '':
print('>>> Errors')
print(' ', errMsg)
return (modelScore, errMsg)
for i in range(len(models)):
# Create a Regressor (input is model)
regressor = KerasRegressor(
build_fn=models[i][1], batch_size=32,
epochs=20) # 1 epoch: all examples have been processed 1 time
# Fit the model to the training data
history = regressor.fit(x=X_train,
y=Y_train,
verbose=1,
epochs=20,
batch_size=32)
# Predict the data for test data
y_pred = regressor.predict(X_test)
score = regressor.score(X_test, Y_test)
mse = mean_squared_error(Y_test, y_pred)
# mean squared error: measure for distance between measurement and prediction
r2 = r2_score(Y_test, y_pred)
# measures 'goodness of fit' (is model complete, 1= optimal)
print()
print(models[i][0] + ": train/test: ")
print(" - X_test has shape: " + str(X_test.shape))
print(" - y_pred has shape: " + str(y_pred.shape))
print(" - score: " + str(score))
print(" - mse: " + str(mse))
print(" - r^2: " + str(r2))
print(" - y_pred: " + str(y_pred))
plt.subplot(2, len(models), i + 1)
plt.scatter(Y_test, y_pred)
def run_regressor(model=LSTM2,
data=None,
data_file='df_dh.csv',
isload_model=True,
testonly=False):
epochs = 8000
path_to_dataset = data_file
sequence_length = SEQ_LENGTH
if data is None:
X_train, y_train, X_test, y_test, X_val, Y_val = get_data(
sequence_length=sequence_length,
stateful=STATEFUL,
path_to_dataset=data_file)
else:
X_train, y_train, X_test, y_test, X_val, Y_val = data
if STATEFUL:
X_test = X_test[:int(X_test.shape[0] / batch_size) * batch_size]
y_test = y_test[:int(y_test.shape[0] / batch_size) * batch_size]
estimator = KerasRegressor(build_fn=lambda x=X_train: model(x))
# if testonly == True:
# # predicted = model.predict(X_test, verbose=1,batch_size=batch_size)
# prediction = estimator.predict(X_test)
# stat_metrics(X_test, y_test, prediction)
# draw_scatter(predicted_arr[0], y_test, X_test, X_train, y_train, data_file)
# return
early_stopping = EarlyStopping(monitor='val_loss', verbose=1, patience=20)
checkpoint = ModelCheckpoint("./lstm.h5",
monitor='val_loss',
verbose=1,
save_best_only=True,
save_weights_only=True)
################
hist = estimator.fit(X_train,
y_train,
validation_data=(X_val, Y_val),
callbacks=[checkpoint],
epochs=epochs,
batch_size=batch_size,
verbose=1)
# prediction = estimator.predict(X_test)
score = mean_squared_error(y_test, estimator.predict(X_test))
estimator_score = estimator.score(X_test, y_test)
print(score)
prediction = estimator.predict(X_test)
# invert predictions
prediction_trans = scaler.inverse_transform(prediction)
X_test_trans = scaler.inverse_transform(X_test)
y_test_trans = scaler.inverse_transform(y_test)
X_train_trans = scaler.inverse_transform(X_train)
y_train_trans = scaler.inverse_transform(y_train)
print(prediction)
print(X_test)
print("##############################################")
# predicted_arr = prediction.T.tolist()
# print(predicted_arr)
draw_scatter(prediction, y_test, X_test, X_train, y_train, data_file)
his_figures(hist)
from keras.wrappers.scikit_learn import KerasRegressor
model = KerasRegressor(build_fn=make_model, epochs=epochs, batch_size=batch_size, verbose=True, callbacks=keras_callbacks)
model.fit(x_train, y_train)
'''
history = model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
shuffle=True,
verbose=2,#0, # Change it to 2, if wished to observe execution
#validation_data=(arr_x_valid, arr_y_valid),
callbacks=keras_callbacks)
'''
y_pred = model.predict(x_test[:20,])
print (y_pred)
print (y_test[:20])
print('KERAS score is %f (traning)' % model.score(x_train, y_train))
print('KERAS score is %f (test)' % model.score(x_test, y_test)) # ??%
'''
from sklearn.metrics import mean_squared_error
score = mean_squared_error(y_test, model.predict(x_test))
print(score)
from sklearn.metrics import mean_absolute_error
score = mean_absolute_error(y_test, model.predict(x_test))
print(score)
'''
def createmodel():
model = Sequential()
model.add(Dense(8, input_dim=8, init='normal', activation='relu'))
model.add(Dense(13, init='normal', activation='relu'))
model.add(Dense(1))
model.compile(loss='mean_squared_error',
optimizer='adam',
metrics=['accuracy'])
return model
tensorboard = TensorBoard(log_dir="logslo1/1",
histogram_freq=0,
write_graph=True,
write_images=True)
estimator = KerasRegressor(build_fn=createmodel)
est = estimator.fit(X_train,
Y_train,
epochs=20,
batch_size=160,
callbacks=[tensorboard])
evaluation = estimator.score(X_test, Y_test)
print(evaluation)
plt.plot(est.history['loss'])
# plt.plot(history.history['test_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.show()
def main():
analysis_score = []
with open(path3, "w", newline="") as f:
writer = csv.writer(f)
for i in [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]:
training_personality = np.loadtxt(path1,\
delimiter=",",\
skiprows=1,\
max_rows=12,\
usecols=(i),\
encoding="utf-8"\
)
training_preference = np.loadtxt(path1,\
delimiter=",",\
skiprows=1,\
max_rows=12,\
usecols=(1, 2, 3, 4, 5),\
encoding="utf-8"\
)
test_preference = np.empty((1, 5))
test_preference[0] = np.loadtxt(path2,
delimiter=",",\
skiprows=0,\
max_rows=1,\
usecols=(1, 2, 3, 4, 5),\
encoding="utf-8"\
)
np.reshape(test_preference, (1, 5))
seed = len(training_personality)
np.random.seed(seed)
model = KerasRegressor(build_fn=reg_model,
epochs=100,
batch_size=10,
verbose=0)
model.fit(training_preference, training_personality)
#kfold = KFold(n_splits=10, random_state=seed)
#調整されたパラメータを見る
#print(i)
#print("model.coef_")
#print(model.coef_)
#print("model.intercept_")
#print(model.intercept_)
print("score(0.5以上が目安)")
print(model.score(training_preference, training_personality))
#予測
print(model.predict(test_preference))
print(model.score(training_preference, training_personality))
#np.savetxt(path3,model.score(training_preference, training_personality))
analysis_score.append(
model.score(training_preference, training_personality))
path4 = "C:\\Users\\bubbl\\OneDrive\\Desktop\\facial_expression_data\\deeplearning_clf_data{}.pkl".format(
i)
joblib.dump(model, path4) #学習データを保存
writer.writerow(analysis_score)
print(analysis_score)
model.add(Dense(256,input_shape=(10,),activation='relu'))
model.add(Dense(128,activation='relu'))
model.add(Dense(4))
model.compile(loss='mae',optimizer='adam',metrics=['mae'])
return model
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.metrics import mean_absolute_error as mae
model=KerasRegressor(build_fn=create_model,epochs=100,verbose=1,batch_size=3)
#4. 평가, 예측
model.fit(x_train,y_train,epochs=100,batch_size=3)
results=cross_val_score(model,x_train,y_train,cv=kfold,n_jobs=1)
print(test.shape)
y_predict=model.predict(x_test)
print(y_predict.shape)
mae_result=mae(y_predict,y_test) #훈련이 얼마나 잘 되었는지 평가
score=model.score(x_test,y_test)
print("r2:",score)
print("result:",results)
print("mae:",mae_result)
"""
mae: 2.58
r2: -2.58
"""
test_new = test_X[:, :, 0].reshape((test_X.shape[0], time_step, 1))
for wey in chosen[s]:
#APPENDING COLUMNS ACCORDING TO THE CHOSEN FEATURES LENGTH FOR TEST SET
test_new = numpy.concatenate(
(test_new, test_X[:, :, wey].reshape(
(test_X.shape[0], time_step, 1))),
axis=2)
# FITTING DATASET
history = kears_estimator.fit(train_new,
train_y,
epochs=num_epochs,
batch_size=batch_size,
verbose=0,
shuffle=False)
score = kears_estimator.score(test_new, test_y)
# # MEASURING TRAIN
# yhat_train = kears_estimator.predict(train_new)
# train_X1 = train_X.reshape((train_X.shape[0], features))
# # invert scaling for actual / appending same colums from train to not have problem with inverse scale
# train_y1 = train_y.reshape((len(train_y), 1))
# inv_y1 = concatenate((train_y1, train_X1[:, -(n_features-1):]), axis=1)
# inv_y1 = scaler.inverse_transform(inv_y1)
# inv_y1 = inv_y1[:,0]
# # invert scaling for forecast/ appending same colums from train to not have problem with inverse scale
# inv_yhat1 = concatenate((yhat_train.reshape(train_X.shape[0],1), train_X1[:, -(n_features-1):]), axis=1)
# inv_yhat1 = scaler.inverse_transform(inv_yhat1)
# inv_yhat1 = inv_yhat1[:,0]
# # calculate RMSE
# rmse_t = sqrt(mean_squared_error(inv_y1, inv_yhat1))
# evaluate model
start = time.time()
model = KerasRegressor(build_fn=baseline_model, epochs=100, batch_size=5, verbose=0)
model.fit(X_train, y_train)
#predictions: test data
y_pred = model.predict(X_test)
print('\nRandom Forest report')
#Scores
print('Train score')
print(model.score(X_train, y_train))
print('Test score')
print(model.score(X_test, y_test))
print('-------------------------------------------------------')
# MAE
print('Mean absolute error')
print(mean_absolute_error(y_test, y_pred))
print('-------------------------------------------------------')
# MSE
print('Mean squared error')
print(mean_squared_error(y_test, y_pred))
print('-------------------------------------------------------')
# R-squared
model.add(Dense(1, kernel_initializer='normal'))
# Compile model
model.compile(loss='mean_squared_error', optimizer='adam')
return model
# fix random seed for reproducibility
seed = 7
np.random.seed(seed)
# evaluate model with standardized dataset
estimator = KerasRegressor(build_fn=baseline_model,
epochs=200, batch_size=5, verbose = 0)
estimator.fit(X_train, y_train)
scr = estimator.score(X_test, y_test)
print(scr)
y_pred = estimator.predict(X_test)
score = mean_squared_error(y_test, estimator.predict(X_test))
print("Deep NN: ", score)
#r2 = r2_score(y_test, y_pred)
#print(r2)
# 0.3445108367171906
# 0.3612083730671892 //200 epochs, no activation
# 0.36304349263413993 //200 epochs , activation = relu
# 0.36586558665547375 // another dense layer
# print(y_pred)
#kfold = KFold(n_splits=10, random_state=seed)
#results = cross_val_score(estimator, X, Y, cv=kfold)
