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)