input: Write a python function to load stock data from a CSV file, normalize it, prepare it for an LSTM model, train the model, and make predictions on stock prices.
  assert np.allclose(predict_stock_price('stock-data.csv')[0], 0.5, atol=0.5)
  assert np.allclose(predict_stock_price('stock-data.csv')[1], 0.3, atol=0.3)
output: def predict_stock_price(file_path):
      import numpy as np
      import pandas as pd
      from sklearn.preprocessing import MinMaxScaler
      from keras.models import Sequential
      from keras.layers import LSTM, Dense
  
      # Load stock data from CSV file
      data = pd.read_csv(file_path)
      data = data['Close'].values.reshape(-1, 1)
      
      # Normalize the data
      scaler = MinMaxScaler(feature_range=(0, 1))
      scaled_data = scaler.fit_transform(data)
      
      # Prepare data for LSTM model
      def create_dataset(dataset, look_back=1):
          X, Y = [], []
          for i in range(len(dataset) - look_back - 1):
              a = dataset[i:(i + look_back), 0]
              X.append(a)
              Y.append(dataset[i + look_back, 0])
          return np.array(X), np.array(Y)
      
      look_back = 1
      X, Y = create_dataset(scaled_data, look_back)
      
      # Reshape input to be [samples, time steps, features]
      X = np.reshape(X, (X.shape[0], 1, X.shape[1]))
      
      # Split data into train and test sets
      train_size = int(len(X) * 0.67)
      test_size = len(X) - train_size
      trainX, testX = X[:train_size], X[train_size:]
      trainY, testY = Y[:train_size], Y[train_size:]
      
      # Create and fit the LSTM network
      model = Sequential()
      model.add(LSTM(4, input_shape=(1, look_back)))
      model.add(Dense(1))
      model.compile(loss='mean_squared_error', optimizer='adam')
      model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)
      
      # Make predictions
      trainPredict = model.predict(trainX)
      testPredict = model.predict(testX)
      
      # Invert predictions
      trainPredict = scaler.inverse_transform(trainPredict)
      trainY = scaler.inverse_transform([trainY])
      testPredict = scaler.inverse_transform(testPredict)
      testY = scaler.inverse_transform([testY])
      
      return testPredict[0][0], testPredict[1][0]