Use the kaggle training model and download your own training model

kaggle Address : https://www.kaggle.com/

1. Upload data sets
   

2. Add data sets that others have uploaded
   

3. View data path

import os
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

4. Add code

# -*- coding: utf-8 -*-
import datetime

import numpy as np
import tensorflow as tf
from tensorflow.keras.layers import Dropout, Dense, SimpleRNN
import matplotlib.pyplot as plt
import os
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error
import math

#  normalization 
sc = MinMaxScaler(feature_range=(0, 1))  #  Define normalization ： Normalize to (0,1) Between 


def get_stock_data(file_path):
    maotai = pd.read_csv(file_path)
    training_set = maotai.iloc[0:2426 - 300, 2:3].values
    test_set = maotai.iloc[2426 - 300:, 2:3].values
    training_set_scaled = sc.fit_transform(training_set)
    test_set_scaled = sc.transform(test_set)
    x_train = []
    y_train = []
    for i in range(60, len(training_set_scaled)):
        x_train.append(training_set_scaled[i - 60:i, 0])
        y_train.append(training_set_scaled[i, 0])
    np.random.seed(7)
    np.random.shuffle(x_train)
    np.random.seed(7)
    np.random.shuffle(y_train)
    x_train = np.array(x_train)
    y_train = np.array(y_train)
    x_train = np.reshape(x_train, (x_train.shape[0], 60, 1))
    x_test = []
    y_test = []
    for i in range(60, len(test_set_scaled)):
        x_test.append(test_set_scaled[i - 60:i, 0])
        y_test.append(test_set_scaled[i, 0])
    x_test = np.array(x_test)
    y_test = np.array(y_test)
    x_test = np.reshape(x_test, (x_test.shape[0], 60, 1))
    return (x_train, y_train), (x_test, y_test)


def load_local_model(model_path):
    if os.path.exists(model_path + '/saved_model.pb'):
        print(datetime.datetime.now())
        local_model = tf.keras.models.load_model(model_path)
    else:
        local_model = tf.keras.Sequential([
            SimpleRNN(80, return_sequences=True),
            Dropout(0.2),
            SimpleRNN(100),
            Dropout(0.2),
            Dense(1)
        ])
        local_model.compile(optimizer=tf.keras.optimizers.Adam(0.001),
                            loss='mean_squared_error')  #  The loss function uses the mean square error 
    return local_model


def show_train_line(history):
    loss = history.history['loss']
    val_loss = history.history['val_loss']
    plt.plot(loss, label='Training Loss')
    plt.plot(val_loss, label='Validation Loss')
    plt.title('Training and Validation Loss')
    plt.legend()
    plt.show()


def stock_predict(model, x_test, y_test):
    #  Test set input model for prediction 
    predicted_stock_price = model.predict(x_test)
    #  Restore forecast data --- from （0,1） Inverse normalization to the original range 
    predicted_stock_price = sc.inverse_transform(predicted_stock_price)
    #  Restore real data --- from （0,1） Inverse normalization to the original range 
    real_stock_price = sc.inverse_transform(np.reshape(y_test, (y_test.shape[0], 1)))
    #  Draw a comparison curve between real data and predicted data 
    plt.plot(real_stock_price, color='red', label='MaoTai Stock Price')
    plt.plot(predicted_stock_price, color='blue', label='Predicted MaoTai Stock Price')
    plt.title('MaoTai Stock Price Prediction')
    plt.xlabel('Time')
    plt.ylabel('MaoTai Stock Price')
    plt.legend()
    plt.show()
    plt.savefig('./model/rnn/compare.jpg')
    mse = mean_squared_error(predicted_stock_price, real_stock_price)
    rmse = math.sqrt(mean_squared_error(predicted_stock_price, real_stock_price))
    mae = mean_absolute_error(predicted_stock_price, real_stock_price)
    print(' Mean square error : %.6f' % mse)
    print(' Root mean square error : %.6f' % rmse)
    print(' Mean absolute error : %.6f' % mae)


if __name__ == '__main__':
    file_path = '/kaggle/input/databases/SH600519.csv'
    (x_train, y_train), (x_test, y_test) = get_stock_data(file_path)
    model_path = "./model/rnn"
    model = load_local_model(model_path)
    history = model.fit(x_train, y_train, batch_size=265, epochs=100, validation_data=(x_test, y_test),validation_freq=1)
    show_train_line(history)
    model.summary()
    model.save(model_path, save_format="tf")
    stock_predict(model, x_test, y_test)

5. choice gpu perhaps tpu
   

6. Save the model
   

7. Download the trained model
   (1) preservation (File–>Save Version)
   
   Save & Run All(Commit) Be sure to choose this
   Advanced Settings–>Always save out perhaps Save output for this version
   ( Now speed up your choice )
   
   Save it and wait for it to finish running
   Find the item you just saved
   

Download complete