main.py

import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.layers import LSTM, Dense, Dropout
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

# Load the dataset
data = pd.read_csv('trading_summary.csv')

# Initialize a dictionary to store models for each company
company_models = {}

# Define features and target variables
features = ['company_share_volume', 'company_trade_volume', 'company_previous_close',
            'company_open_price', 'company_highest_price', 'company_lowest_price']
target = 'company_last_trade_price'

# Function to create the time series dataset
def create_dataset(features, target, time_step=1):
    dataX, dataY = [], []
    for i in range(len(features) - time_step):
        a = features[i:(i + time_step), :]
        dataX.append(a)
        dataY.append(target[i + time_step])
    return np.array(dataX), np.array(dataY)

# Set the time step
time_step = 1  # Adjusted time step

# Initialize FastAPI
app = FastAPI()

# Define a request model for the API
class CompanyRequest(BaseModel):
    company_name: str

# Train a separate model for each company
for company_name, company_data in data.groupby('company_name'):
    # Normalize the features and target
    scaler_features = MinMaxScaler(feature_range=(0, 1))
    scaler_target = MinMaxScaler(feature_range=(0, 1))
    scaled_features = scaler_features.fit_transform(company_data[features])
    scaled_target = scaler_target.fit_transform(company_data[[target]])

    # Ensure time step is appropriate for the data size
    if len(company_data) <= time_step:
        continue  # Skip this company if dataset is too small

    # Create the dataset
    X, y = create_dataset(scaled_features, scaled_target, time_step)

    # Build and train the LSTM model
    model = Sequential()
    model.add(LSTM(50, return_sequences=True, input_shape=(time_step, len(features))))
    model.add(LSTM(50, return_sequences=False))
    model.add(Dropout(0.2))
    model.add(Dense(25))
    model.add(Dense(1))
    model.compile(optimizer='adam', loss='mean_squared_error')
    model.fit(X, y, batch_size=1, epochs=1)

    # Save the model for future use
    model.save(f"lstm_model_{company_name}.h5")

    # Add the model to the dictionary
    company_models[company_name] = model

# Define the prediction endpoint
@app.post("/report/prediction")
def predict_next_prices(request: CompanyRequest):
    company_name = request.company_name
    if company_name not in company_models:
        raise HTTPException(status_code=404, detail="Company not found")

    # Load the model for the specified company
    model = load_model(f"lstm_model_{company_name}.h5")

    # Get the data for the specified company
    company_data = data[data['company_name'] == company_name]
    if len(company_data) < time_step:
        raise HTTPException(status_code=404, detail="Not enough data to make prediction")

    # Normalize company data
    scaler_features = MinMaxScaler(feature_range=(0, 1))
    scaler_target = MinMaxScaler(feature_range=(0, 1))
    scaled_features = scaler_features.fit_transform(company_data[features])
    scaled_target = scaler_target.fit_transform(company_data[[target]])

    # Create dataset for the company
    company_X, company_y = create_dataset(scaled_features, scaled_target, time_step)

    # Initialize an empty list to store predicted prices
    predicted_prices = []

    # Take the last steps of the company's data
    last_steps = company_X[-1]
    last_steps = np.reshape(last_steps, (1, time_step, len(features)))

    # Initialize a list to store current last trade prices
    current_last_trade_prices = []

    # Get the last few actual trade prices used in the prediction
    f = open("trading_summary.csv", "r")
    for i in f:
        if company_name in i:
            if company_name == i.split(",")[0]:
                current_last_trade_prices.append(float(i.split(",")[-3]))


    # Predict the next 5 prices iteratively
    for _ in range(5):
        next_price_scaled = model.predict(last_steps)
        predicted_prices.append(float(scaler_target.inverse_transform(next_price_scaled)[0][0]))

        # Shift the input sequence by one step and update last_steps
        last_steps = np.roll(last_steps, -1, axis=1)
        last_steps[0, -1] = next_price_scaled
        last_steps = np.reshape(last_steps, (1, time_step, len(features)))

    return {
        "company_name": company_name,
        "current_last_trade_prices": current_last_trade_prices,
        "predicted_last_trade_prices": predicted_prices
    }

if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="127.0.0.1", port=8003)