Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· OpenAIAi2 WildChat-4.8M (AI2)

In this below code for stock market prediction implement the following: 1. Increasing…

  1. User

    In this below code for stock market prediction implement the following:

    1. Increasing the size of training data: More data can help the model to better understand the underlying patterns, leading to better generalization on unseen test data.
    2. Regularization: You can add some regularization techniques like L1 or L2 regularization to prevent overfitting by constraining the model’s weights.
    3. Simplifying the model: Reduce the complexity of the model by using fewer or smaller layers, which can prevent it from learning noise and enhance its capacity to generalize.
    4. Cross-validation: Perform k-fold cross-validation to get a better estimate of the model’s performance on unseen data. This can provide more insights about the model’s generalization ability.

    Code: import yfinance as yf import pandas as pd import numpy as np from sklearn.preprocessing import MinMaxScaler from keras.models import Sequential from keras.layers import Dense, LSTM from keras.callbacks import LambdaCallback

    nifty = yf.download('^NSEI', start='2009-01-01', end='2021-01-01')

    def supertrend(df, period=10, multiplier=3): hl = (df['High'] + df['Low']) / 2 atr = df['High'].rolling(period).max() - df['Low'].rolling(period).min()

    up = hl - multiplier * atr
    dn = hl + multiplier * atr
    
    df['ST'] = 0
    df['ST'][0] = (df['High'][0] + df['Low'][0]) / 2
    
    position = 'none'
    
    for i in range(1, len(df)):
        if df['Close'][i] > up[i]:
            if position != 'buy':
                position = 'buy'
                df['ST'][i] = dn[i]
            else:
                df['ST'][i] = max(df['ST'][i - 1], dn[i])
        elif df['Close'][i] < dn[i]:
            if position != 'sell':
                position = 'sell'
                df['ST'][i] = up[i]
            else:
                df['ST'][i] = min(df['ST'][i - 1], up[i])
        else:
            df['ST'][i] = df['ST'][i - 1]
    
    return df
    

    nifty = supertrend(nifty) nifty.head()

    dataset = nifty['Close'].values dataset = dataset.astype('float32') dataset = dataset.reshape(-1, 1) scaler = MinMaxScaler(feature_range=(0, 1)) dataset = scaler.fit_transform(dataset)

    def create_dataset(dataset, look_back=1): dataX, dataY = [], [] for i in range(len(dataset)-look_back-1): a = dataset[i:(i+look_back), 0] dataX.append(a) dataY.append(dataset[i + look_back, 0]) return np.array(dataX), np.array(dataY)

    train_size = int(len(dataset) * 0.8) test_size = len(dataset) - train_size train, test = dataset[:train_size], dataset[train_size:]

    look_back = 1 trainX, trainY = create_dataset(train, look_back) testX, testY = create_dataset(test, look_back)

    trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1])) testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))

    model = Sequential() model.add(LSTM(100, input_shape=(1, look_back))) model.add(Dense(1))

    model.compile(loss='mean_squared_error', optimizer='adam') model.fit(trainX, trainY, epochs=200, batch_size=1, verbose=0)

    trainPredict = model.predict(trainX) testPredict = model.predict(testX)

    trainPredict = scaler.inverse_transform(trainPredict) trainY = scaler.inverse_transform([trainY]) testPredict = scaler.inverse_transform(testPredict) testY = scaler.inverse_transform([testY])

    import matplotlib.pyplot as plt

    trainPredictPlot = np.empty_like(dataset) trainPredictPlot[:, :] = np.nan trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict

    testPredictPlot = np.empty_like(dataset) testPredictPlot[:, :] = np.nan testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict

    plt.plot(scaler.inverse_transform(dataset), label='Actual') plt.plot(trainPredictPlot, label='Train Prediction') plt.plot(testPredictPlot, label='Test Prediction') plt.legend() plt.show()

    model.save('my_model.h5')

    from sklearn.metrics import mean_squared_error import math

    trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0])) print('Train Score: %.2f RMSE' % (trainScore)) testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0])) print('Test Score: %.2f RMSE' % (testScore))

    1. Take the last look_back days (last day in this case) of the dataset

    last_day = dataset[-look_back:]

    2. Scale the input using the fitted MinMaxScaler

    last_day_scaled = scaler.transform(last_day)

    3. Reshape the input to match the required model input shape

    last_day_scaled_reshaped = np.reshape(last_day_scaled, (1, 1, look_back))

    4. Use model.predict() to predict the scaled value for ‘2021-01-02’

    next_day_scaled_prediction = model.predict(last_day_scaled_reshaped)

    5. Inverse-transform the predicted scaled value to the original range using the MinMaxScaler

    next_day_prediction = scaler.inverse_transform(next_day_scaled_prediction)

    6. Print or use the predicted value

    print("Prediction for 2021-01-02: ", next_day_prediction[0][0])

  2. Assistant
    import yfinance as yf
    import pandas as pd
    import numpy as np
    from sklearn.preprocessing import MinMaxScaler
    from keras.models import Sequential
    from keras.layers import Dense, LSTM
    from keras.callbacks import LambdaCallback
    from keras.regularizers import L1L2
    from sklearn.model_selection import TimeSeriesSplit
    
    nifty = yf.download('^NSEI', start='2009-01-01', end='2021-01-01')
    
    def supertrend(df, period=10, multiplier=3):
        hl = (df['High'] + df['Low']) / 2
        atr = df['High'].rolling(period).max() - df['Low'].rolling(period).min()
        
        up = hl - multiplier * atr
        dn = hl + multiplier * atr
    
        df['ST'] = 0
        df['ST'][0] = (df['High'][0] + df['Low'][0]) / 2
        
        position = 'none'
        
        for i in range(1, len(df)):
            if df['Close'][i] > up[i]:
                if position != 'buy':
                    position = 'buy'
                    df['ST'][i] = dn[i]
                else:
                    df['ST'][i] = max(df['ST'][i - 1], dn[i])
            elif df['Close'][i] < dn[i]:
                if position != 'sell':
                    position = 'sell'
                    df['ST'][i] = up[i]
                else:
                    df['ST'][i] = min(df['ST'][i - 1], up[i])
            else:
                df['ST'][i] = df['ST'][i - 1]
    
        return df
    
    nifty = supertrend(nifty)
    nifty.head()
    
    dataset = nifty['Close'].values
    dataset = dataset.astype('float32')
    dataset = dataset.reshape(-1, 1)
    scaler = MinMaxScaler(feature_range=(0, 1))
    dataset = scaler.fit_transform(dataset)
    
    def create_dataset(dataset, look_back=1):
    	dataX, dataY = [], []
    	for i in range(len(dataset)-look_back-1):
    		a = dataset[i:(i+look_back), 0]
    		dataX.append(a)
    		dataY.append(dataset[i + look_back, 0])
    	return np.array(dataX), np.array(dataY)
    
    look_back = 1
    
    X, y = create_dataset(dataset, look_back)
    
    X = np.reshape(X, (X.shape[0], 1, X.shape[1]))
    
    # 1. Increasing the size of training data
    train_size = int(len(X) * 0.9)
    test_size = len(X) - train_size
    X_train, X_test = X[:train_size], X[train_size:]
    y_train, y_test = y[:train_size], y[train_size:]
    
    # 4. Cross-validation
    tscv = TimeSeriesSplit(n_splits=5)
    
    for train_index, test_index in tscv.split(X_train):
      X_train_cv, X_valid_cv = X_train[train_index], X_train[test_index]
      y_train_cv, y_valid_cv = y_train[train_index], y_train[test_index]
    
      # 3. Simplifying the model -  reduce layers or use smaller layers
      model = Sequential()
      model.add(LSTM(50, input_shape=(1, look_back), kernel_regularizer=L1L2(l1=0.0, l2=0.1)))
      model.add(Dense(1))
    
      # 2. Regularization
      model.compile(loss='mean_squared_error', optimizer='adam')
      model.fit(X_train_cv, y_train_cv, epochs=200, batch_size=1, verbose=0, validation_data=(X_valid_cv, y_valid_cv))
    
    trainPredict = model.predict(X_train)
    testPredict = model.predict(X_test)
    
    trainPredict = scaler.inverse_transform(trainPredict)
    y_train = scaler.inverse_transform([y_train])
    testPredict = scaler.inverse_transform(testPredict)
    y_test = scaler.inverse_transform([y_test])
    
    import matplotlib.pyplot as plt
    
    trainPredictPlot = np.empty_like(dataset)
    trainPredictPlot[:, :] = np.nan
    trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict
    
    testPredictPlot = np.empty_like(dataset)
    testPredictPlot[:, :] = np.nan
    testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict
    
    plt.plot(scaler.inverse_transform(dataset), label='Actual')
    plt.plot(trainPredictPlot, label='Train Prediction')
    plt.plot(testPredictPlot, label='Test Prediction')
    plt.legend()
    plt.show()
    
    model.save('my_model.h5')
    
    from sklearn.metrics import mean_squared_error
    import math
    
    trainScore = math.sqrt(mean_squared_error(y_train[0], trainPredict[:,0]))
    print('Train Score: %.2f RMSE' % (trainScore))
    testScore = math.sqrt(mean_squared_error(y_test[0], testPredict[:,0]))
    print('Test Score: %.2f RMSE' % (testScore))
    
    last_day = dataset[-look_back:]
    last_day_scaled = scaler.transform(last_day)
    last_day_scaled_reshaped = np.reshape(last_day_scaled, (1, 1, look_back))
    next_day_scaled_prediction = model.predict(last_day_scaled_reshaped)
    next_day_prediction = scaler.inverse_transform(next_day_scaled_prediction)
    
    print("Prediction for 2021-01-02: ", next_day_prediction[0][0])
    
  3. User

    ValueError Traceback (most recent call last) in <cell line: 9>() 7 testPredictPlot = np.empty_like(dataset) 8 testPredictPlot[:, :] = np.nan ----> 9 testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict 10 11 plt.plot(scaler.inverse_transform(dataset), label='Actual')

    ValueError: could not broadcast input array from shape (294,1) into shape (292,1)

  4. Assistant

    I apologize for the mistake. It appears that there is a mismatch in length between testPredictPlot and testPredict arrays when trying to plot the test predictions. Let's fix the issue by updating the test prediction length. Replace the plotting code with the following updated code:

    import matplotlib.pyplot as plt
    
    trainPredictPlot = np.empty_like(dataset)
    trainPredictPlot[:, :] = np.nan
    trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict
    
    testPredictPlot = np.empty_like(dataset)
    testPredictPlot[:, :] = np.nan
    testPredictPlot[len(trainPredict)+(look_back*2)+1:len(trainPredict)+(look_back*2)+1+len(testPredict), :] = testPredict
    
    plt.plot(scaler.inverse_transform(dataset), label='Actual')
    plt.plot(trainPredictPlot, label='Train Prediction')
    plt.plot(testPredictPlot, label='Test Prediction')
    plt.legend()
    plt.show()
    
    

    This should resolve the ValueError and plot the graph correctly.