Build Machine Learning Models (linear regression, ridge regression, and lasso) to Predict and Deploy in Flask

regiapriandi | Aug. 19, 2023, 5:04 p.m.

Lately, many people are busy investing in stocks or other online-based investments such as gold and dollar investments. In carrying out college assignments, namely the task of building machine learning-based applications.

My friends and I in a group that we call friends of mass organizations decided to build an application for predicting the price of gold, silver, and the dollar against the rupiah for tomorrow’s prices where this application was built to help people who want to invest in gold or dollars by predicting the price of tomorrow.

predicting prices the next day will increase or decrease which will help people see the trend in the price of gold, silver, and the dollar against the rupiah to make it easier for them to invest and minimize losses.

for this project built from scratch together using GitHub, for GitHub link this project https://github.com/regiapriandi012/PricePredictions.git and for directory structure like this,

└── PricePredictions
    ├── model
    │   ├── __init__.py
    │   ├── modelDolarRidge.py
    │   ├── modelDolarLasso.py
    │   ├── modelDolarLinear.py
    │   ├── modelEmasRidge.py
    │   ├── modelEmasLasso.py
    │   ├── modelEmasLinear.py
    │   ├── modelPerakRidge.py
    │   ├── modelPerakLasso.py 
    │   └── modelPerakLinear.py   
    ├── server
    │   ├── __init__.py
    │   ├── conf
    │   │    ├── __init__.py
    │   │    ├── database.ini
    │   │    └── setting.py
    │   ├── __init__.py
    │   └── connect.py
    ├── static
    │   ├── img
    │   │   ├── bagus.jpg
    │   │   ├── emas.jpg
    │   │   ├── fahri.jpg
    │   │   ├── logo.jpg
    │   │   ├── perak.jpg
    │   │   ├── reqi.jpg
    │   │   ├── sine.jpg
    │   │   └── uang.jpg
    │   └── style.css
    ├── templates
    │   ├── index.html
    │   └── model.html
    ├── __init__.py
    ├── app.py
    ├── requirements.txt
    └── README.md

For the first time, we create each machine learning model that is adjusted to the series of gold, silver, and dollar prices against the rupiah. here we use the PostgreSQL database to store data on the price of gold, silver, and dollars against the rupiah. Before creating some models, we make a connection to the server first.

import psycopg2
import pandas as pd
from .conf import config

# Obtain the configuration parameters
params = config()
# Connect to the PostgreSQL database
conn = psycopg2.connect(**params)
# Create a new cursor
cur = conn.cursor()

# A function that takes in a PostgreSQL query and outputs a pandas database
def create_pandas_table(sql_query, database=conn):
    table = pd.read_sql_query(sql_query, database)
    return table

# Utilize th24re create_pandas_table function to create a Pandas data frame
# Store the data as a variable
data_emas = create_pandas_table("SELECT * FROM emas")
data_perak = create_pandas_table("SELECT * FROM perak")
data_dolar = create_pandas_table("SELECT * FROM dolar")
# Close the cursor and connection to so the server can allocate

# bandwidth to other requests
cur.close()
conn.close()

to retrieve the dataset from a database, we use setting.py

from configparser import ConfigParser

#directory di laptop @beroek
#def config(filename='C:/Users/Aceri3/PycharmProjects/PricePredictions/server/conf/database.ini', section='postgresql'):
#directory di laptop @mbagusi
#def config(filename='D:/project vscode/PricePredictions/server/conf/database.ini', section='postgresql'):
#directory di laptop @regi
#def config(filename='/Users/regia/PycharmProjects/pythonProject/KECERDASANBUATAN/FINALL/server/conf/database.ini', section='postgresql'):
    # create a parser

    parser = ConfigParser()
    # read configServer file
    parser.read(filename)

    # get section, default to postgresql
    db = {}
    if parser.has_section(section):
        params = parser.items(section)
        for param in params:
            db[param[0]] = param[1]
    else:
        raise Exception('Section {0} not found in the {1} file'.format(section, filename))

    return db

after setting up to connect to the database and retrieve data from the database, then we go into the initiation for each model, for here we only show one type of model, namely the gold price prediction model using the linear regression method, the rest can be seen in the Github repository.

from sklearn.linear_model import LinearRegression
import numpy as np
from ..server import data_emas as data
import datetime
import pandas as pd
from sklearn import metrics
besok = datetime.date.today() + datetime.timedelta(days=1)

date = data["date"]
date_predict = np.array([str(str(besok.year)+'-'+str(besok.month)+'-'+str(besok.day))])
price = data["price"]

def to_datetime(date):
    df = pd.DataFrame({'date': date})
    df.date = pd.to_datetime(df.date)
    return df.date

def to_datetime_pred(date_predict):
    dfe = pd.DataFrame({'prediksi': date_predict})
    dfe.prediksi = pd.to_datetime(dfe.prediksi)
    return dfe.prediksi

x = to_datetime(date).values.astype(float).reshape(-1, 1)
x_predict = to_datetime_pred(date_predict).values.astype(float).reshape(-1, 1)
y = price.values.reshape(-1, 1)

lin = LinearRegression()
lin.fit(x, y)

def coef_intercept(lin):
    coef = lin.coef_
    intercept = lin.intercept_
    return coef, intercept

def prediction(lin):
    lin_predict = lin.predict(x)
    lin_pred_future = lin.predict(x_predict)
    return lin_predict, lin_pred_future

coef, intercept = coef_intercept(lin)
lin_predict, lin_pred_future = prediction(lin)

rmse = np.sqrt(metrics.mean_squared_error(y, lin_predict))

after successfully creating the required machine learning model, then create a web display using HTML CSS, and javascript (for chart.js graphs). lastly, we made the main application using the Flask framework, in the app.py file, there is integration between several models and web interface.

from flask import Flask, render_template, request
from .model.modelEmasLinear import lin_pred_future as el
from .model.modelDolarLinear import lin_pred_future as dl
from .model.modelPerakLinear import lin_pred_future as pl
from .model.modelEmasRidge import rid_pred_future as er
from .model.modelDolarRidge import rid_pred_future as dr
from .model.modelPerakRidge import rid_pred_future as pr
from .model.modelDolarLasso import las_pred_future as dla
from .model.modelPerakLasso import las_pred_future as pla
from .model.modelEmasLasso import las_pred_future as ela
import base64
from io import BytesIO
from matplotlib.figure import Figure
import datetime

besok = datetime.date.today() + datetime.timedelta(days=1)
app = Flask(__name__)

@app.route("/")
def index():
    return render_template('index.html')

@app.route("/index")
def indexx():
    return render_template('index.html')

@app.route("/model")
def model():
    return render_template('model.html')

@app.route('/', methods=['POST'])
def modelll():
    from .model.modelEmasLinear import coef as cel, intercept as iel, rmse as rel
    from .model.modelPerakLinear import coef as cpl, intercept as ipl, rmse as rpl
    from .model.modelDolarLinear import coef as cdl, intercept as idl, rmse as rdl
    from .model.modelEmasRidge import coef as cer, intercept as ier, rmse as rer
    from .model.modelDolarRidge import coef as cdr, intercept as idr, rmse as rdr
    from .model.modelPerakRidge import coef as cpr, intercept as ipr, rmse as rpr
    from .model.modelDolarLasso import coef as cdla, intercept as idla, rmse as rdla
    from .model.modelEmasLasso import coef as cela, intercept as iela, rmse as rela
    from .model.modelPerakLasso import coef as cpla, intercept as ipla, rmse as rpla

    prediksi = request.form['prediksi']
    metode = request.form['metode']

    if metode == "Linear Regression" and prediksi == "Harga Emas":
        from .model.modelEmasLinear import date, date_predict, y, to_datetime, to_datetime_pred, lin_predict, lin_pred_future
        fig = Figure(figsize=(10, 8))
        ax = fig.subplots()
        ax.scatter(to_datetime(date), y, color='green')
        ax.plot(to_datetime(date), lin_predict)
        ax.scatter(to_datetime_pred(date_predict), lin_pred_future, color="blue")
        ax.tick_params(labelrotation=30)
        ax.set_ylabel("Dalam Rupiah")
        ax.set_xlabel("Tanggal (jangka 14 hari)")
        ax.legend(['Garis linear regression', 'Harga', 'Prediksi'])
        ax.set_title("Grafik Linear Regression Prediksi Harga Emas")

        buf = BytesIO()
        fig.savefig(buf, format="png")

        data = base64.b64encode(buf.getbuffer()).decode("ascii")
        return render_template('model.html', data=data, prediksi=prediksi, metode=metode, hasil='Rp. {}'.format(float(el)), date=str(besok.strftime("%A"))+', '+str(besok.day)+'/'+str(besok.month)+'/'+str(besok.year), coef=float(cel), intercept=float(iel), rmse=rel)

    elif metode == "Linear Regression" and prediksi == "Harga Perak":
        from .model.modelPerakLinear import date, date_predict, y, to_datetime, to_datetime_pred, lin_predict, lin_pred_future
        fig = Figure(figsize=(10, 8))
        ax = fig.subplots()
        ax.scatter(to_datetime(date), y, color='green')
        ax.plot(to_datetime(date), lin_predict)
        ax.scatter(to_datetime_pred(date_predict), lin_pred_future, color="blue")
        ax.tick_params(labelrotation=30)
        ax.set_ylabel("Dalam Rupiah")
        ax.set_xlabel("Tanggal (jangka 14 hari)")
        ax.legend(['Garis linear regression', 'Harga', 'Prediksi'])
        ax.set_title("Grafik Linear Regression Prediksi Harga Perak")

        buf = BytesIO()
        fig.savefig(buf, format="png")

        data = base64.b64encode(buf.getbuffer()).decode("ascii")
        return render_template('model.html', data=data, prediksi=prediksi, metode=metode, hasil='Rp. {}'.format(float(pl)), date=str(besok.strftime("%A"))+', '+str(besok.day)+'/'+str(besok.month)+'/'+str(besok.year), coef=float(cpl), intercept=float(ipl), rmse=rpl)

    elif metode == "Linear Regression" and prediksi == "Harga Dollar":
        from .model.modelDolarLinear import date, date_predict, y, to_datetime, to_datetime_pred, lin_predict, lin_pred_future
        fig = Figure(figsize=(10, 8))
        ax = fig.subplots()
        ax.scatter(to_datetime(date), y, color='green')
        ax.plot(to_datetime(date), lin_predict)
        ax.scatter(to_datetime_pred(date_predict), lin_pred_future, color="blue")
        ax.tick_params(labelrotation=30)
        ax.set_ylabel("Dalam Rupiah")
        ax.set_xlabel("Tanggal (jangka 14 hari)")
        ax.legend(['Garis linear regression', 'Harga', 'Prediksi'])
        ax.set_title("Grafik Linear Regression Prediksi Harga Dollar")

        buf = BytesIO()
        fig.savefig(buf, format="png")

        data = base64.b64encode(buf.getbuffer()).decode("ascii")
        return render_template('model.html', data=data, prediksi=prediksi, metode=metode, hasil='Rp. {}'.format(float(dl)), date=str(besok.strftime("%A"))+', '+str(besok.day)+'/'+str(besok.month)+'/'+str(besok.year), coef=float(cdl), intercept=float(idl), rmse=rdl)

    elif metode == "Lasso" and prediksi == "Harga Emas":
        from .model.modelEmasLasso import date, date_predict, y, to_datetime, to_datetime_pred, las_predict, las_pred_future
        fig = Figure(figsize=(10, 8))
        ax = fig.subplots()
        ax.scatter(to_datetime(date), y, color='green')
        ax.plot(to_datetime(date), las_predict)
        ax.scatter(to_datetime_pred(date_predict), las_pred_future, color="blue")
        ax.tick_params(labelrotation=30)
        ax.set_ylabel("Dalam Rupiah")
        ax.set_xlabel("Tanggal (jangka 14 hari)")
        ax.legend(['Garis Lasso', 'Harga', 'Prediksi'])
        ax.set_title("Grafik Lasso Prediksi Harga Emas")

        buf = BytesIO()
        fig.savefig(buf, format="png")

        data = base64.b64encode(buf.getbuffer()).decode("ascii")
        return render_template('model.html', data=data, prediksi=prediksi, metode=metode, hasil='Rp. {}'.format(float(ela)), date=str(besok.strftime("%A"))+', '+str(besok.day)+'/'+str(besok.month)+'/'+str(besok.year), coef=float(cela), intercept=float(iela), rmse=rela)

    elif metode == "Lasso" and prediksi == "Harga Perak":
        from .model.modelPerakLasso import date, date_predict, y, to_datetime, to_datetime_pred, las_predict, las_pred_future
        fig = Figure(figsize=(10, 8))
        ax = fig.subplots()
        ax.scatter(to_datetime(date), y, color='green')
        ax.plot(to_datetime(date), las_predict)
        ax.scatter(to_datetime_pred(date_predict), las_pred_future, color="blue")
        ax.tick_params(labelrotation=30)
        ax.set_ylabel("Dalam Rupiah")
        ax.set_xlabel("Tanggal (jangka 14 hari)")
        ax.legend(['Garis Lasso', 'Harga', 'Prediksi'])
        ax.set_title("Grafik Lasso Prediksi Harga Perak")

        buf = BytesIO()
        fig.savefig(buf, format="png")

        data = base64.b64encode(buf.getbuffer()).decode("ascii")
        return render_template('model.html', data=data, prediksi=prediksi, metode=metode, hasil='Rp. {}'.format(float(pla)), date=str(besok.strftime("%A"))+', '+str(besok.day)+'/'+str(besok.month)+'/'+str(besok.year), coef=float(cpla), intercept=float(ipla), rmse=rpla)

    elif metode == "Lasso" and prediksi == "Harga Dollar":
        from .model.modelDolarLasso import date, date_predict, y, to_datetime, to_datetime_pred, las_predict, las_pred_future
        fig = Figure(figsize=(10, 8))
        ax = fig.subplots()
        ax.scatter(to_datetime(date), y, color='green')
        ax.plot(to_datetime(date), las_predict)
        ax.scatter(to_datetime_pred(date_predict), las_pred_future, color="blue")
        ax.tick_params(labelrotation=30)
        ax.set_ylabel("Dalam Rupiah")
        ax.set_xlabel("Tanggal (jangka 14 hari)")
        ax.legend(['Garis Lasso', 'Harga', 'Prediksi'])
        ax.set_title("Grafik Lasso Prediksi Harga Dollar")

        buf = BytesIO()
        fig.savefig(buf, format="png")

        data = base64.b64encode(buf.getbuffer()).decode("ascii")
        return render_template('model.html', data=data, prediksi=prediksi, metode=metode, hasil='Rp. {}'.format(float(dla)), date=str(besok.strftime("%A"))+', '+str(besok.day)+'/'+str(besok.month)+'/'+str(besok.year), coef=float(cdla), intercept=float(idla), rmse=rdla)


    elif metode == "Ridge Regression" and prediksi == "Harga Emas":
        from .model.modelEmasRidge import date, date_predict, y, to_datetime, to_datetime_pred, rid_predict, rid_pred_future
        fig = Figure(figsize=(10, 8))
        ax = fig.subplots()
        ax.scatter(to_datetime(date), y, color='green')
        ax.plot(to_datetime(date), rid_predict)
        ax.scatter(to_datetime_pred(date_predict), rid_pred_future, color="blue")
        ax.tick_params(labelrotation=30)
        ax.set_ylabel("Dalam Rupiah")
        ax.set_xlabel("Tanggal (jangka 14 hari)")
        ax.legend(['Garis Ridge Regression', 'Harga', 'Prediksi'])
        ax.set_title("Grafik Ridge Regression Prediksi Harga Emas")

        buf = BytesIO()
        fig.savefig(buf, format="png")

        data = base64.b64encode(buf.getbuffer()).decode("ascii")
        return render_template('model.html', data=data, prediksi=prediksi, metode=metode, hasil='Rp. {}'.format(float(er)), date=str(besok.strftime("%A"))+', '+str(besok.day)+'/'+str(besok.month)+'/'+str(besok.year), coef=float(cer), intercept=float(ier), rmse=rer)

    elif metode == "Ridge Regression" and prediksi == "Harga Perak":
        from .model.modelPerakRidge import date, date_predict, y, to_datetime, to_datetime_pred, rid_predict, rid_pred_future
        fig = Figure(figsize=(10, 8))
        ax = fig.subplots()
        ax.scatter(to_datetime(date), y, color='green')
        ax.plot(to_datetime(date), rid_predict)
        ax.scatter(to_datetime_pred(date_predict), rid_pred_future, color="blue")
        ax.tick_params(labelrotation=30)
        ax.set_ylabel("Dalam Rupiah")
        ax.set_xlabel("Tanggal (jangka 14 hari)")
        ax.legend(['Garis Ridge Regression', 'Harga', 'Prediksi'])
        ax.set_title("Grafik Ridge Regression Prediksi Harga Perak")

        buf = BytesIO()
        fig.savefig(buf, format="png")

        data = base64.b64encode(buf.getbuffer()).decode("ascii")
        return render_template('model.html', data=data, prediksi=prediksi, metode=metode, hasil='Rp. {}'.format(float(pr)), date=str(besok.strftime("%A"))+', '+str(besok.day)+'/'+str(besok.month)+'/'+str(besok.year), coef=float(cpr), intercept=float(ipr), rmse=rpr)

    elif metode == "Ridge Regression" and prediksi == "Harga Dollar":
        from .model.modelDolarRidge import date, date_predict, y, to_datetime, to_datetime_pred, rid_predict, rid_pred_future
        fig = Figure(figsize=(10, 8))
        ax = fig.subplots()
        ax.scatter(to_datetime(date), y, color='green')
        ax.plot(to_datetime(date), rid_predict)
        ax.scatter(to_datetime_pred(date_predict), rid_pred_future, color="blue")
        ax.tick_params(labelrotation=30)
        ax.set_ylabel("Dalam Rupiah")
        ax.set_xlabel("Tanggal (jangka 14 hari)")
        ax.legend(['Garis Ridge Regression', 'Harga', 'Prediksi'])
        ax.set_title("Grafik Ridge Regression Prediksi Harga Dolar")

        buf = BytesIO()
        fig.savefig(buf, format="png")

        data = base64.b64encode(buf.getbuffer()).decode("ascii")
        return render_template('model.html', data=data, prediksi=prediksi, metode=metode, hasil='Rp. {}'.format(float(dr)), date=str(besok.strftime("%A"))+', '+str(besok.day)+'/'+str(besok.month)+'/'+str(besok.year), coef=float(cdr), intercept=float(idr), rmse=rdr)

if __name__ == "__main__":
    app.run(debug=True)

to review the prediction interface like this that’s all from me and my friends for the projects



that have been completed and distributed to friends, thank you for the development of this project running smoothly, hopefully, this little information will be useful for friends.

About Me

I am Regi Apriandi, Welcome to the blog page, I hope this page can be useful for readers who have visited, Thank you.

RSS

0 comments

Leave a comment