AI-powered Stock Predictor Python, AI

```python
import yfinance as yf
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
import matplotlib.pyplot as plt

def fetch_data(ticker, start_date, end_date):
    """Fetches stock data from Yahoo Finance."""
    try:
        data = yf.download(ticker, start=start_date, end=end_date)
        return data
    except Exception as e:
        print(f"Error fetching data for {ticker}: {e}")
        return None

def preprocess_data(data, feature='Close', sequence_length=60):
    """Preprocesses the stock data for LSTM model."""
    if data is None or data.empty:
        print("No data to preprocess.")
        return None, None, None

    data = data[[feature]].values
    scaler = MinMaxScaler(feature_range=(0, 1))
    scaled_data = scaler.fit_transform(data)

    X, y = [], []
    for i in range(sequence_length, len(scaled_data)):
        X.append(scaled_data[i-sequence_length:i, 0])
        y.append(scaled_data[i, 0])

    X, y = np.array(X), np.array(y)
    X = np.reshape(X, (X.shape[0], X.shape[1], 1))  # Reshape for LSTM

    return X, y, scaler

def create_lstm_model(input_shape):
    """Creates an LSTM model."""
    model = Sequential()
    model.add(LSTM(units=50, return_sequences=True, input_shape=input_shape))
    model.add(Dropout(0.2))
    model.add(LSTM(units=50, return_sequences=False))
    model.add(Dropout(0.2))
    model.add(Dense(units=1))  # Predicts one value (closing price)
    model.compile(optimizer='adam', loss='mean_squared_error')
    return model

def train_model(model, X_train, y_train, epochs=25, batch_size=32):
    """Trains the LSTM model."""
    model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size)
    return model

def predict_future(model, last_sequence, days_to_predict, scaler):
    """Predicts future stock prices."""
    predictions = []
    current_sequence = last_sequence.copy()

    for _ in range(days_to_predict):
        # Reshape the input for prediction
        current_sequence_reshaped = np.reshape(current_sequence, (1, current_sequence.shape[0], 1))

        # Make the prediction
        predicted_scaled = model.predict(current_sequence_reshaped)

        # Inverse transform to get the original scale
        predicted_price = scaler.inverse_transform(predicted_scaled)[0, 0]
        predictions.append(predicted_price)

        # Update the sequence with the predicted value
        current_sequence = np.roll(current_sequence, -1)
        current_sequence[-1] = predicted_scaled

    return predictions


def evaluate_model(model, X_test, y_test, scaler):
    """Evaluates the model on test data."""
    y_pred_scaled = model.predict(X_test)
    y_pred = scaler.inverse_transform(y_pred_scaled)
    y_true = scaler.inverse_transform(y_test.reshape(-1, 1))  # Reshape to (n, 1)

    rmse = np.sqrt(np.mean((y_pred - y_true)**2))
    print(f"Root Mean Squared Error (RMSE): {rmse}")
    return y_pred, y_true, rmse

def plot_results(y_true, y_pred, ticker):
    """Plots the predicted vs actual stock prices."""
    plt.figure(figsize=(12, 6))
    plt.plot(y_true, label='Actual Price', color='blue')
    plt.plot(y_pred, label='Predicted Price', color='red')
    plt.title(f'{ticker} Stock Price Prediction')
    plt.xlabel('Time')
    plt.ylabel('Stock Price')
    plt.legend()
    plt.show()


def main(ticker='AAPL', start_date='2015-01-01', end_date='2023-01-01', sequence_length=60, days_to_predict=30):
    """Main function to orchestrate the stock prediction process."""

    # 1. Fetch Data
    data = fetch_data(ticker, start_date, end_date)
    if data is None or data.empty:
        print("Aborting prediction due to data issues.")
        return

    # 2. Preprocess Data
    X, y, scaler = preprocess_data(data, sequence_length=sequence_length)
    if X is None or y is None:
        print("Aborting prediction due to preprocessing issues.")
        return

    # 3. Split Data
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

    # 4. Create and Train Model
    model = create_lstm_model(input_shape=(X_train.shape[1], 1))
    model = train_model(model, X_train, y_train)

    # 5. Evaluate Model
    y_pred, y_true, rmse = evaluate_model(model, X_test, y_test, scaler)

    # 6. Plot Results
    plot_results(y_true, y_pred, ticker)

    # 7. Predict Future
    last_sequence = X[-1]
    future_predictions = predict_future(model, last_sequence, days_to_predict, scaler)

    print("\nFuture Predictions:")
    for i, prediction in enumerate(future_predictions):
        print(f"Day {i+1}: {prediction:.2f}")

if __name__ == "__main__":
    main()
```