def init_data():
X, y = import_power_plant_data()
X, y = X.to_numpy(), y.to_numpy()
#print(X,y)
#exit()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,shuffle=True, random_state=1234)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)
opt = SGD(lr=0.01)
epoch = 10000
regressor = LinearRegression(opt, epoch=epoch)
x_plot = list(range(1,epoch+1))
all_mse = regressor.fit(X_train, y_train)
predicted = regressor.predict(X_test)
#print(len(predicted))
#exit()
mse_value = Metrics.mse(y_test, predicted)
#print(len(x_plot), len(all_mse))
#print(mse_value)
#y_pred_line = regressor.predict(X)
#cmap = plt.get_cmap('viridis')
#fig = plt.figure(figsize=(8,6))
#m1 = plt.scatter(X_train, y_train, color=cmap(0.9), s=10)
#m2 = plt.scatter(X_test, y_test, color=cmap(0.5), s=10)
#plt.plot(x_plot, all_mse, color = "blue", linewidth=2)
Plot.plot_time_series(x_plot, all_mse, "mse_plot", "number of iterations", "Mean Square Error (MSE)", "MSE vs Number of iterations")
plt.show()
def update_plot(self, plot_state):
data = plot_state['inputs']
X, y = np.array(data['x']), np.array(data['y'])
regressor = LinearRegression(
basis_function=ScalarBasisFunctions.Polynomial(
plot_state['Polynomial Degree']),
l2_cost=plot_state['L2 Weight Penalty'])
regressor.fit(X, y)
inputs = np.linspace(*X_RANGE, self.PLOT_POINTS)
self.fit_line.data_source.data = dict(x=inputs,
y=regressor.predict(inputs))
def linear_predict(stock_code):
if "useStockPrice" not in request.args or "n" not in request.args:
return jsonify({
"success": False,
"error": {
"code": "invalid-argument"
}
})
model_options = {
"stock_code":
stock_code,
"use_stock_price":
False if request.args.get("useStockPrice") != "true" else True,
"n":
int(request.args.get("n"))
}
model = LinearRegression(model_options,
load=True,
saved_model_dir="./saved_models/linear")
if model.model is None:
return jsonify({
"success": False,
"error": {
"code": "invalid-argument"
}
})
if not model_options["use_stock_price"]:
stock_prices = pd.read_csv("./data/stock_prices/" + stock_code +
".csv",
nrows=1)
predictions = model.predict(stock_prices.loc[0, "adjusted_close"])
else:
predictions = model.predict()
return jsonify({"success": True, "predictions": predictions.tolist()})
def generate_regression_predictions():
X, Y = get_regression_training_data()
test_X = get_regression_testing_data()
lr = LinearRegression()
lr.fit(X, Y)
predictions = [str(datetime.timedelta(seconds=int(s))) for s in lr.predict(test_X)]
for i, x in enumerate(test_X):
# set those who don't have a full marathon to -1
if x[2] == -1:
predictions[i] = -1
return predictions
def main(_):
"""High level pipeline.
This script performs the trainsing, evaling and testing state of the model.
"""
# learning_rate = FLAGS.learning_rate
# feature_type = FLAGS.feature_type
# model_type = FLAGS.model_type
# num_steps = FLAGS.num_steps
feature_type = 'default'
model_type = 'svm'
# Load dataset.
data = read_dataset('data/train_lab.txt', 'data/image_data')
# Data Processing.
data = preprocess_data(data, 'default')
print("Finish preprocessing...")
# Initialize model.
ndim = data['image'].shape[1]
if model_type == 'linear':
model = LinearRegression(ndim, 'uniform')
elif model_type == 'logistic':
model = LogisticRegression(ndim, 'uniform')
elif model_type == 'svm':
model = SupportVectorMachine(ndim, 'uniform')
# Train Model.
print("Start to train the model...")
model = train_model(data, model)
# Eval Model.
print("Start to evaluate the model...")
data_val = read_dataset('data/val_lab.txt', 'data/image_data')
data_val = preprocess_data(data_val, feature_type)
loss, acc = eval_model(data_val, model)
print(loss, acc)
# Test Model.
print("Start doing the test")
data_test = read_dataset('data/test_lab.txt', 'data/image_data')
print("Start preprocess testing data")
data_test = preprocess_data(data_test, feature_type)
print("Making predictions")
data_test['label'] = model.predict(model.forward(data_test['image']))
print("Output the results to csv file")
write_dataset('data/test_lab.txt', data_test)
# Generate Kaggle output.
print("Finished!")
def main():
parser = argparse.ArgumentParser(description='Linear Regression test')
parser.add_argument('-m',
'--method',
type=str,
default='ols',
help='model method: ols or grad_descent')
parser.add_argument('-n',
'--n_iter',
type=int,
default=50,
help='number of iterations for grad_descent')
args = parser.parse_args()
method = args.method
n_iter = args.n_iter
X, y, m, bias = \
generate_linear_data(n_samples=1000, n_features=10, bias=10)
X_train, X_test, y_train, y_test = split_dataset(X, y)
print("Training size: %s, Test size %s" % (len(X_train), len(X_test)))
print("-" * 20)
# Fit and predict
model = LinearRegression(n_iter=n_iter)
model.fit(X_train, y_train, method)
y_pred = model.predict(X_test)
print("-" * 20)
# Scoring
model.score(y_test, y_pred)
print("-" * 20)
print("True coefs: ", np.insert(m, 0, bias))
print("Model coefs:", model.beta_hat)
print("-" * 20)
# Plotting
plot_regression_residual(y_test, y_pred, bins=int(len(X_train) / 20))
if method == 'grad_descent':
plot_iteration_vs_cost(n_iter, model.cost_h)
