def createPredictionModel(trainX, trainY, method = 'LR'):
print('Creating base prediction model')
if method == 'LR':
model = LinearRegression(fit_intercept=True)
elif method == 'Ridge':
model = Ridge(5)
elif method == 'keras':
from keras.models import Sequential
from keras.layers import Dense, Dropout
model = Sequential()
model.add(Dense(units=3, activation='relu', input_dim=trainX.shape[1]))
model.add(Dropout(0.01))
model.add(Dense(units=1))
model.compile(loss='mse', optimizer='adam')
else:
print('Unknown model! Implement yourself?')
raise ValueError()
model.fit(trainX, trainY)#, epochs=50, verbose=2) #do not use model = when using keras
res = model.predict(trainX) - trainY # calculate residuals
stdevRes = res.std() # calculate the standard deviation of the residuals
return model, res, stdevRes
def get_classifier(name_of_reg, params):
reg = None
if name_of_reg == 'MultiLinear':
reg = LinearRegression()
reg.fit(X_train, y_train)
elif name_of_reg == 'Support Vector':
reg = SVR(kernel=params['kernel'])
reg.fit(X_train, y_train)
elif name_of_reg == 'DecisionTree':
reg = DecisionTreeRegressor(random_state=0)
reg.fit(X_train, y_train)
elif name_of_reg == 'RandomForest':
reg = RandomForestRegressor(
n_estimators=params['n_estimators'],
random_state=0,
min_samples_leaf=.0001)
reg.fit(X_train, y_train)
elif name_of_reg == 'ExtraTree':
reg = ExtraTreesRegressor(
n_estimators=params['n_estimators'])
reg.fit(X_train, y_train)
elif name_of_reg == 'GradientBoosting':
reg = GradientBoostingRegressor(random_state=0)
reg.fit(X_train, y_train)
elif name_of_reg == 'XGBoost':
reg = XGBRegressor()
reg.fit(X_train, y_train)
elif name_of_reg == 'Artificial Neural Network':
reg = tf.keras.models.Sequential()
reg.add(
tf.keras.layers.Dense(units=60, activation='relu'))
reg.add(
tf.keras.layers.Dense(units=60, activation='relu'))
reg.add(tf.keras.layers.Dense(units=1))
reg.compile(optimizer='adam',
loss='mean_squared_error')
reg.fit(X_train,
y_train,
batch_size=32,
epochs=params['epochs'])
else:
st.warning('Select your choice of algorithm')
return reg
def fitted_q_iteration(self,
four_tuples_set,
stop,
algo="Linear Regression"):
N = 0
print("Computing fitted q iteration ...")
print("{} / 100".format((N / stop) * 100))
while N < stop: # temp stopping condition
N += 1
X = []
y = []
for t in four_tuples_set:
X.append([t[0][0], t[0][1], t[1]])
if N == 1:
y.append(t[2])
else:
y.append(t[2] + self.domain.d_factor * max(
self.qn_approximation[-1].predict(
np.array([t[3][0], t[3][1], -4]).reshape(1, -1))
[0], self.qn_approximation[-1].predict(
np.array([t[3][0], t[3][1], 4]).reshape(1, -1))[0])
)
if algo == "Linear Regression":
model = LinearRegression()
elif algo == "Extremely Randomized Trees":
model = ExtraTreesRegressor(n_estimators=10)
elif algo == "Neural Network":
X = np.array(X)
y = np.array(y)
model = Sequential()
model.add(Dense(8, input_dim=3, activation='relu'))
model.add(Dense(4, activation='relu'))
model.add(Dense(1, activation='linear'))
model.compile(loss='mean_squared_error',
optimizer='adam',
metrics=['mse'])
# model.fit(X, y, epochs=10, batch_size=10, verbose=0)
model.fit(X, y, epochs=100, batch_size=128, verbose=2)
self.qn_approximation.append(model)
if algo != "Neural Network":
self.qn_approximation.append(
model.fit(np.array(X), np.array(y)))
print("{} / 100".format((N / stop) * 100))
return self.qn_approximation[-1]
plt.ylabel("User1 Grade")
plt.show()
print("Fitting parameters: intercept", a, ",regression coefficient：", b)
print("Best Fitting Line: Y = ", round(a, 2), "+", round(b[0], 2), "* X")
import keras
import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.optimizers import SGD
model = Sequential()
model.add(Dense(units=10, input_dim=1))
model.add(Activation('tanh'))
model.add(Dense(units=1))
model.add(Activation('tanh'))
sgd = SGD(lr=0.3)
model.compile(optimizer=sgd, loss='mse')
for step in range(3):
cost = model.train_on_batch(user1.month, user1.grade)
if step % 6 == 0:
print('cost: ', cost)
W, b = model.layers[0].get_weights()
print('W：', W, ' b: ', b)
# In[ ]:
Y = train2['LOS'].values
X = train2.drop(columns=['LOS'])
print("Total Dataset Shape - ", X.shape)
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=42)
print("Train Set shape - ", X_train.shape)
print("Test Set shape - ", X_test.shape)
# In[ ]:
model = Sequential()
model.add(Dense(64, input_dim=X_train.shape[1], activation='relu'))
#model.add(Dense(1024, activation='relu'))
#model.add(Dense(512, activation='relu'))
#model.add(Dense(1024, activation='relu'))
model.add(Dense(512, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(1)) # Output
opt = keras.optimizers.Adam(learning_rate=0.01)
model.compile(optimizer=opt,loss='mean_squared_error')
estp = EarlyStopping(monitor='val_loss', min_delta=0,patience=5, verbose=1, mode='auto',restore_best_weights=True)
model.fit(X_train,y_train,validation_split=0.15,shuffle='True',verbose=2,epochs=200, callbacks=[estp])
# In[ ]:
X = np.reshape(xs, (-1, 1))
y = np.reshape(ys, (-1, 1))
X_test = np.array([10, 20, -2])
y_test = np.array([19.0, 39, -5])
model.fit(X, y)
prediction = model.predict(np.reshape(X_test, (-1, 1)))
print("MAE:", mean_absolute_error(y_test, prediction))
print("Expected: [[-5.]]", "Got:", model.predict(np.reshape([-2], (-1, 1))))
# Tensorflow
print("\n##### USING TENSORFLOW")
model = Sequential()
model.add(Dense(units=1, input_shape=[1]))
# SGD: Stochastic Gradient Descent
model.compile(optimizer="sgd", loss="mean_squared_error")
model.fit(
xs,
ys,
epochs=500,
)
print("Expected: [[19.]]", "Got:", model.predict([10.0]))
scaler = MinMaxScaler(feature_range=(0, 1)) dataset_scaled = scaler.fit_transform(dataset) X = dataset_scaled[:, 0] y = dataset_scaled[:, 1] #X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0) dataset_sz = X.shape[0] train_sz = X_train.shape[0] test_sz = X_test.shape[0] regressor = Sequential() regressor.add(Dense(units = 500, kernel_initializer = 'uniform', activation = 'relu', input_dim = 1)) regressor.add(Dropout(.2)) regressor.add(Dense(units = 500, kernel_initializer = 'uniform', activation = 'relu')) regressor.add(Dropout(.2)) regressor.add(Dense(units = 500, kernel_initializer = 'uniform', activation = 'relu')) regressor.add(Dropout(.2)) regressor.add(Dense(units = 1, kernel_initializer = 'uniform', activation = 'sigmoid')) regressor.compile(optimizer = 'adam', loss = 'mean_squared_error') regressor.fit(X_train, y_train, batch_size = 32, epochs = 200)
# use neural network
import keras
from keras.layers import Dense
from keras.models import Sequential
from keras import backend
from matplotlib import pyplot
def R2(y_true, y_pred):
return 1- (backend.mean(backend.square(y_pred - y_true), axis=-1)/backend.mean(backend.square(backend.mean(y_true) - y_true), axis=-1))
n_cols = X.shape[1]
input_shape = (n_cols,)
# Specify the model
model = Sequential()
model.add(Dense(350, activation='relu', input_shape = input_shape))
model.add(Dense(200, activation='relu'))
model.add(Dense(150, activation='relu'))
model.add(Dense(1))
# Compile the model
model.compile(optimizer='adam', loss='mean_squared_error', metrics=['mse', 'mae','mape', R2])
# train model
history = model.fit(train_features, train_labels, validation_data=(test_features,test_labels), epochs=1000, batch_size=1200)
# plot metrics
pyplot.plot(history.history['val_mean_squared_error'])
pyplot.plot(history.history['val_mean_absolute_error'])
pyplot.plot(history.history['val_mean_absolute_percentage_error'])
pyplot.plot(history.history['val_R2'])
pyplot.show()
model.fit(x_train, y_train) new_preds = model.predict(x_test) # Results k_rms = np.sqrt(np.mean(np.power((np.array(y_test) - np.array(preds)), 2))) print(k_rms) test['Predictions'] = 0 test['Predictions'] = new_preds plt.plot(train['Adj. Close']) plt.plot(test[['Adj. Close', 'Predictions']]) # Multilayer Perceptron model = tf.keras.models.Sequential() model.add(tf.keras.layers.Dense(100, activation=tf.nn.relu)) model.add(tf.keras.layers.Dense(100, activation=tf.nn.relu)) model.add(tf.keras.layers.Dense(1, activation=tf.nn.relu)) model.compile(optimizer='adam', loss='mean_squared_error') X_train = np.array(x_train) Y_train = np.array(y_train) model.fit(X_train, Y_train, epochs=500) preds = model.predict(x_test) # Results mlp_rms = np.sqrt(np.mean(np.power((np.array(y_test) - np.array(preds)), 2))) print(mlp_rms) test['Predictions'] = 0
##Dumping from sklearn.externals import joblib joblib.dump(regressor, 'regressor.sav') # Importing the Keras libraries and packages from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM from keras.layers import Dropout # Initialising the RNN regressor = Sequential() teste = X_train.reshape((1291, 216, 1)) # Adding the first LSTM layer and some Dropout regularisation regressor.add(Dense(50, input_dim=86, activation='relu')) # Adding a second LSTM layer and some Dropout regularisation regressor.add(Dense(50, input_dim=20, activation='relu')) # Adding a third LSTM layer and some Dropout regularisation regressor.add(Dense(25, input_dim=20, activation='softmax')) # Adding the output layer regressor.add(Dense(units=1)) # Compiling the RNN regressor.compile(optimizer='adam', loss='mean_squared_error') # Fitting the RNN to the Training set history = regressor.fit(X_train, y_train, epochs=100, batch_size=32)
classifier = XGBClassifier()
classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
ac = accuracy_score(y_test,y_pred)
print('XGBoost:',ac)
"""
# ANN
import keras
from keras.models import Sequential
from keras.layers import Dense
classifier = Sequential()
classifier.add(
Dense(units=9,
kernel_initializer='uniform',
activation='relu',
input_dim=19))
classifier.add(Dense(units=4, kernel_initializer='uniform', activation='relu'))
classifier.add(Dense(units=1, kernel_initializer='uniform', activation='relu'))
classifier.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
classifier.fit(X, y, batch_size=10, epochs=200)
#Confusion_Matrix
cm = confusion_matrix(y_test, y_pred)
print(cm)
pid = test['PassengerId']
test = test.iloc[:, 1:].drop(['Name', 'Ticket', 'Cabin'], axis=1)
data = data['2017-05-01':'2018-09-02']
data_train = data.copy() #取2014年前的数据建模
print("data_train", type(data_train))
data_mean = data_train.mean()
print("data_mean:", data_mean)
data_std = data_train.std()
print("data_std:", data_std)
data_train = (data_train - data_mean) / data_std #数据标准化
x_train = data_train[feature].as_matrix() #特征数据
y_train = data_train[u'AQI'].as_matrix() #标签数据
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
model = Sequential() #建立模型
model.add(Dense(input_dim=6, output_dim=12))
model.add(Activation('relu')) #用relu函数作为激活函数，能够大幅提供准确度
model.add(Dense(input_dim=12, output_dim=1))
model.compile(loss='mean_squared_error', optimizer='adam') #编译模型
model.fit(x_train, y_train, nb_epoch=10000, batch_size=16) #训练模型，学习一万次
model.save_weights(modelfile) #保存模型参数
#预测，并还原结果。
x = ((data[feature] - data_mean[feature]) / data_std[feature]).as_matrix()
data[u'AQI_pred'] = model.predict(x) * data_std[u'AQI'] + data_mean[u'AQI']
data.to_csv(pridictfile)
import matplotlib.pyplot as plt #画出预测结果图
p = data[[u'AQI', 'AQI_pred']].plot(subplots=True, style=['b-o', 'r-*'])
plt.show()
pridictDataToMysql(data)
X.append(
np.array(stock_final.iloc[i:i + window_size, :]).reshape(
window_size * 4, 1))
Y.append(np.array(stock.iloc[i + window_size, 4]).reshape(1, 1))
train_X, test_X, train_label, test_label = train_test_split(X,
Y,
test_size=0.1,
shuffle=False)
train_X = np.array(train_X)
test_X = np.array(test_X)
train_label = np.array(train_label)
test_label = np.array(test_label)
model = Sequential()
#add model layers
model.add((LSTM(128, return_sequences=True)))
model.add((LSTM(64, return_sequences=False)))
model.add(Dense(16, activation='relu'))
model.add(Dense(1, activation='linear'))
model.compile(optimizer='RMSprop', loss='mse')
model.fit(train_X,
train_label,
validation_data=(test_X, test_label),
epochs=50,
shuffle=False)
print(model.evaluate(test_X, test_label))
# model.summary()
predicted = model.predict(test_X)
test_label[:, 0] = y_scaler.inverse_transform(test_label[:, 0])
predicted = np.array(predicted[:, 0]).reshape(-1, 1)
predicted = y_scaler.inverse_transform(predicted)
#converting dataset into x_train and y_train
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(dataset)
x_train, y_train = [], []
for i in range(60,len(train)):
x_train.append(scaled_data[i-60:i,0])
y_train.append(scaled_data[i,0])
x_train, y_train = np.array(x_train), np.array(y_train)
x_train = np.reshape(x_train, (x_train.shape[0],x_train.shape[1],1))
# create and fit the LSTM network
model = Sequential()
model.add(LSTM(units=50, return_sequences=True, input_shape=(x_train.shape[1],1)))
model.add(LSTM(units=50))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(x_train, y_train, epochs=3, batch_size=1)
"""#### Validation
The number of prior datapoints used as input defines the one-dimensional (1D) subsequence of data that the LSTM will read and learn to extract features. We denote it here by `subsequence_length` which takes the past hour of data. We can also tune this hyperparameter using cross validation across multiple validatin datasets to arrive at an optimal value
"""
subsequence_length = 60 #past one hour
#predicting next values, using past 60 from the train data
inputs = new_data[len(new_data) - len(valid) - subsequence_length:].values
inputs = inputs.reshape(-1,1)
inputs = scaler.transform(inputs)
# X.append(np.array(temp).reshape(50, 1))
# Y.append(np.array(temp2).reshape(1,1))
train_X,test_X,train_label,test_label = train_test_split(X, Y, test_size=0.1,shuffle=False)
len_t = len(train_X)
# train_X,valid_X,train_label,valid_label = train_test_split(train_X, train_label, test_size=0.2,shuffle=True)
train_X = np.array(train_X)
test_X = np.array(test_X)
train_label = np.array(train_label)
test_label = np.array(test_label)
# valid_label = np.array(valid_label)
# valid_X = np.array(valid_X)
train_X = train_X.reshape(train_X.shape[0],7,50,1)
test_X = test_X.reshape(test_X.shape[0],7,50,1)
model = Sequential()
#add model layers
model.add(TimeDistributed(Conv1D(128, kernel_size=1, activation='relu', input_shape=(None,50,1))))
model.add(TimeDistributed(MaxPooling1D(2)))
model.add(TimeDistributed(Conv1D(256, kernel_size=1, activation='relu')))
model.add(TimeDistributed(MaxPooling1D(2)))
model.add(TimeDistributed(Conv1D(512, kernel_size=1, activation='relu')))
model.add(TimeDistributed(MaxPooling1D(2)))
model.add(TimeDistributed(Flatten()))
model.add(Bidirectional(LSTM(200,return_sequences=True)))
model.add(Dropout(0.25))
model.add(Bidirectional(LSTM(200,return_sequences=False)))
model.add(Dropout(0.5))
model.add(Dense(1, activation='linear'))
model.compile(optimizer='adam', loss='mse')
model.fit(train_X, train_label, validation_data=(test_X,test_label), epochs=200)
print(model.summary())
print(model.evaluate(test_X,test_label))
model = Ridge()
model.fit(x_train, y_train)
from sklearn.linear_model import ElasticNet
model = ElasticNet()
model.fit(x_train, y_train)
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras import optimizers
sgd = optimizers.SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
model = Sequential()
model.add(Dense(units=3, activation='relu', input_shape=(3, )))
model.add(Dense(units=300, activation='relu'))
model.add(Dense(units=300, activation='relu'))
model.add(Dense(units=1, activation='sigmoid'))
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
model.fit(X_train, y_train, batch_size=32, epochs=1000)
y_pred = model.predict(X_test)
y_pred_D = sc_y.inverse_transform(y_pred)
score = model.evaluate(X_test, Y_test)
def model_predictions(modeloption, x_train, y_train, x_test, y_test):
if modeloption == 'lineareg':
model = LinearRegression()
model.fit(x_train, y_train) # Training
y_predicted = model.predict(x_test) # Test
elif modeloption == 'ridge':
model = RidgeCV(alphas=ALPHAS)
model.fit(x_train, y_train)
print(model.alpha_)
y_predicted = model.predict(x_test)
elif modeloption == 'mlp':
# Build Keras model
model = Sequential()
"""
#model.add(keras.layers.Dropout(0.2, input_shape=(x_train.shape[1],)))
model.add(Dense(NEURONSPERLAYER, input_shape =(x_train.shape[1],)))
model.add(Activation('relu'))
#model.add(keras.layers.Dropout(0.2))
#model.add(Dense(NEURONSPERLAYER))
#model.add(Activation('relu'))
#model.add(keras.layers.Dropout(0.2))
model.add(Dense(NEURONSOUTPUT))
model.add(Activation('linear'))
"""
#trial11
#model.add(keras.layers.Dropout(0.3, input_shape=(x_train.shape[1],)))
model.add(
Dense(NEURONSPERLAYER,
activation='sigmoid',
input_shape=(x_train.shape[1], )))
model.add(Dense(1000, activation=None))
model.compile(loss='mean_squared_error', optimizer=OPTIMIZER)
history = model.fit(x_train,
y_train,
epochs=EPOCHS,
batch_size=BATCH,
verbose=0)
y_predicted = model.predict(x_test,
batch_size=BATCH,
verbose=0,
steps=None)
# show training loss and test loss
print(history.history['loss'])
print(model.evaluate(x_test, y_test, batch_size=BATCH, verbose=0))
elif modeloption == 'knn':
model = KNeighborsRegressor(n_neighbors=NEIGHBORS, weights='distance')
model.fit(x_train, y_train)
y_predicted = model.predict(x_test)
elif modeloption == 'kernelreg':
model = KernelRidge(kernel=KERNEL,
degree=DEGREE,
alpha=0.001,
coef0=10)
model.fit(x_train, y_train)
y_predicted = model.predict(x_test)
return y_predicted
path = os.getcwd() + '\izeqi\data\data_time.txt'
data2 = pd.read_csv(path,header='infer',index_col=0)
datatime=data2.values
x_train_time1= datatime[:, 0:input_size_1].astype(float)
y_train_time1 = datatime[:, input_size_1:]
scalertime_x = preprocessing.StandardScaler().fit(x_train_time1)
scalertime_y = preprocessing.StandardScaler().fit(y_train_time1)
x_train_time = scalertime_x.transform(x_train_time1)
y_train_time= scalertime_y.transform(y_train_time1)
model_time = LinearRegression()
model_time.fit(x_train_time, y_train_time)
'''
model_time=Sequential()
model_time.add(Dense(input_dim=1,kernel_initializer='random_uniform',
bias_initializer='random_uniform',units=20))
model_time.add(keras.layers.advanced_activations.ELU(alpha=2))
model_time.add(Dropout(0.2))
model_time.add(Dense(1))
model_time.compile(optimizer='sgd',
loss='mse')'''
#second model to calucate the price
model_value = Sequential()
#random init and zero_bias -----input layer of 4 units,and first layer is 17 units
x = np.reshape(x,(-1,1))
model=LinearRegression()
model.fit(x,y)
pred_y = model.predict(x)
plt.title("Simple Linear Regression Model")
plt.plot(x, y, '.',label="Origin")
plt.plot(x, pred_y,'.',label="Model")
plt.legend()
plt.xlabel("Key")
plt.ylabel("Pred_Pos = CDF(Key)")
plt.show()
model = Sequential()
model.add(Dense(8, input_dim=1, activation="relu"))
model.add(Dense(8, activation="relu"))
model.add(Dense(1))
sgd=keras.optimizers.SGD(lr=0.0001) # lr:學習率,可調參數
model.compile(loss="mse", optimizer=sgd, metrics=["mse"])
model.fit(norm_x, y, epochs=1000, batch_size=32, verbose=0) # norm_x:訓練資料, y:訓練目標
pred_y = model.predict(norm_x)
plt.title("Neural Network 8x8 Model")
plt.plot(x, y, '.',label="Origin")
plt.plot(x, pred_y,'.',label="Model")
plt.legend()
plt.xlabel("Key")
plt.ylabel("Pred_Pos = CDF(Key)")
plt.show()
def modelling(X_train,
y_train,
X_test,
y_test,
fs='lasso',
method='ols',
select=500):
if method == 'ols':
from sklearn.linear_model import LinearRegression
mod = LinearRegression().fit(X_train, y_train)
if method == 'elasticNet':
from sklearn.linear_model import ElasticNetCV
mod = ElasticNetCV(l1_ratio=[.1, .5, .7, .9, .95, .99, 1],
cv=10,
tol=0.001,
n_jobs=7)
mod.fit(X_train, y_train)
if method == 'xgboost':
import xgboost as xg
max_depth = 3
min_child_weight = 10
subsample = 0.5
colsample_bytree = 0.6
objective = 'reg:linear'
num_estimators = 1000
learning_rate = 0.3
mod = xg.XGBRegressor(max_depth=max_depth,
min_child_weight=min_child_weight,
subsample=subsample,
colsample_bytree=colsample_bytree,
objective=objective,
n_estimators=num_estimators,
learning_rate=learning_rate)
mod.fit(X_train, y_train)
# implement CV
if method == 'nn':
from sklearn.preprocessing import StandardScaler
from keras.models import Sequential
from keras.layers import Dense
from keras.callbacks import EarlyStopping
from keras.callbacks import ModelCheckpoint
from keras.models import load_model
mod = Sequential()
# input layer
mod.add(Dense(50, activation='relu', input_shape=(int(select), )))
# hidden layer
mod.add(Dense(50, activation='relu'))
# output layer
mod.add(Dense(1, activation='linear'))
# mod.summary()
mod.compile(loss='mse', optimizer='adam', metrics=['accuracy'])
# patient early stopping and select best model (not always the last)
es = EarlyStopping(monitor='val_loss',
mode='min',
verbose=1,
patience=200)
mc = ModelCheckpoint('best_model.h5',
monitor='val_acc',
mode='max',
verbose=1,
save_best_only=True)
history = mod.fit(X_train,
y_train,
epochs=1000,
batch_size=25,
verbose=1,
validation_data=(Xt, y_test),
callbacks=[es])
# pickle.dump(mod, open('models/' + fs + '_' + method + '_' +
# select + '.sav', 'wb'))
if method == 'nn':
rmse = (sum((np.concatenate(mod.predict(X_test)) - y_test)**2) /
y_test.size)**(.5)
else:
rmse = (sum((mod.predict(X_test) - y_test)**2) / y_test.size)**(.5)
return mod, rmse
print(y_test_predict.max())
plt.scatter(y_test, y_test_predict)
plt.show()
#MSE OF THE TESTING SET
mse_test = np.mean(np.square(np.subtract(y_test, y_test_predict)))
print("Testing set Mean Squared Error: {}".format(mse_test))
"""CNN"""
model = Sequential()
# The Input Layer :
model.add(
Dense(4096,
kernel_initializer='normal',
input_dim=X_train.shape[1],
activation='relu'))
# The Hidden Layers :
'''
NN_model.add(Dense(2048, kernel_initializer='normal',activation='relu'))
NN_model.add(Dense(1024, kernel_initializer='normal',activation='relu'))
'''
model.add(Dense(512, kernel_initializer='normal', activation='relu'))
model.add(Dense(256, kernel_initializer='normal', activation='relu'))
# The Output Layer :
model.add(Dense(1, kernel_initializer='normal', activation='linear'))
# Compile the network :
import tensorflow as tf from tensorflow import keras from tensorflow.keras.layers import Dense, Dropout from keras.wrappers.scikit_learn import KerasRegressor from sklearn.model_selection import cross_val_score, KFold from sklearn.preprocessing import StandardScaler from sklearn.pipeline import Pipeline X = data.drop(columns=['probability', 'Patient_ID', 'Health_Camp_ID']) y = data['probability'] X = np.array(X[['Category1', 'Var1', 'Category2', 'Var5', 'LinkedIn_Shared']]) y = np.array(y) model = keras.Sequential() model.add(Dense(10, input_dim=5, activation="relu")) model.add(Dense(8, activation="relu")) model.add(Dense(3, activation="relu")) model.add(Dense(1, activation='sigmoid')) model.compile(loss='mean_squared_error', optimizer='adam') # model.summary() callback = tf.keras.callbacks.EarlyStopping(monitor='loss', patience=5) hist = model.fit(X, y, epochs=50, batch_size=1024, callbacks=[callback], verbose=0) # # 7. Lasso Regression from sklearn import linear_model
#predicting the testset result
y_pred = regressor.predict(testdata)
y_pred = pd.DataFrame(y_pred)
y_pred.rename(columns={0: 'Price'}, inplace=True)
y_pred.to_excel("forestx.xlsx", index=False)
# Importing the Keras libraries and packages
# import keras
from keras.models import Sequential
from keras.layers import Dense
# Initialising the ANN
regressor = Sequential()
# Adding the input layer and the first hidden layer
regressor.add(
Dense(output_dim=6, init='uniform', activation='relu', input_dim=12))
# Adding the second hidden layer
regressor.add(Dense(output_dim=6, init='uniform', activation='relu'))
# Adding the second hidden layer
regressor.add(Dense(output_dim=6, init='uniform', activation='relu'))
# Adding the output layer
regressor.add(Dense(output_dim=1, init='uniform', activation='linear'))
# Compiling the ANN
regressor.compile(optimizer='adam',
loss='mean_absolute_error',
metrics=['mean_absolute_error'])
# Fitting the ANN to the Training set
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(dataset)
x_train, y_train = [], []
for i in range(60,len(train)):
x_train.append(scaled_data[i-60:i,0])
y_train.append(scaled_data[i,0])
x_train, y_train = np.array(x_train), np.array(y_train)
x_train = np.reshape(x_train, (x_train.shape[0],x_train.shape[1],1))
#check for best units
myRMS = []
for p in range (40,60):
model = Sequential()
model.add(LSTM(units=p, return_sequences=True, input_shape=(x_train.shape[1],1)))
model.add(LSTM(units=p))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(x_train, y_train, epochs=10, batch_size=32, verbose=2)
#predicting values, using past 60 from the train data
inputs = new_data[len(new_data) - len(valid) - 60:].values
inputs = inputs.reshape(-1,1)
inputs = scaler.transform(inputs)
X_test = []
for i in range(60,inputs.shape[0]):
X_test.append(inputs[i-60:i,0])
X_test = np.array(X_test)
#Neural Network
import tensorflow as tf
from keras.models import Sequential
from keras.layers.core import Dense, Activation, Flatten, Dropout
from keras.callbacks import EarlyStopping
from keras.optimizers import RMSprop
from keras.layers import Conv1D, MaxPooling1D
from keras.optimizers import SGD
from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt
import tensorflow as tf
from sklearn.metrics import roc_auc_score
model=Sequential()
model.add(Dense(100, activation='sigmoid', use_bias = True))
model.add(Dense(100, activation='sigmoid', use_bias = True))
model.add(Dense(10, activation='sigmoid', use_bias = True))
model.add(Dense(10, activation='sigmoid', use_bias = 2))
model.add(Dense(5, activation='sigmoid', use_bias=10))
model.add(Dense(3, activation='softmax'))
model.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])
early_stopping = EarlyStopping(monitor='loss', patience=1.99, mode='min')
history = model.fit(X_train, y_train, batch_size=64, epochs=100, verbose=1, validation_data= None,callbacks=[early_stopping])
from keras.models import model_from_json
model_json = model.to_json()
with open("model.json", "w") as json_file:
json_file.write(model_json)
