!pip install ultralyticsplus mplfinance yfinance

# Load libraries
import cv2
import requests
import os
from ultralyticsplus import YOLO, render_result
import yfinance as yf
import pandas as pd
import mplfinance as mpf
from PIL import Image
import numpy as np

def fetch_stock_data(symbol, start_date, end_date):
  data = yf.download(symbol, start=start_date, end=end_date)
  return data

def prepare_data(data):
  data['Date'] = pd.to_datetime(data.index)
  data['High'].fillna(method='ffill', inplace=True)
  data['Low'].fillna(method='ffill', inplace=True)
  return data

def create_candlestick_chart(data, save_path):
  mpf.plot(data, type='candle', style='charles', title='Stock Price', ylabel='Price', savefig=save_path)

def load_model(model_path):
  model = YOLO(model_path)
  model.overrides['conf'] = 0.25
  model.overrides['iou'] = 0.45
  model.overrides['agnostic_nms'] = False
  model.overrides['max_det'] = 1
  return model

def predict_trends(model, chart_path):
  image = cv2.imread(chart_path)
  results = model.predict(image, verbose=False)
  render = render_result(model=model, image=image, result=results[0])
  return render

def main():
    symbol = 'ASML.AS'
    start_date = '2023-01-01'
    end_date = '2023-05-31'
    model_path = 'foduucom/stockmarket-future-prediction'
    chart_save_path = 'candlestick_chart.png'

    data = fetch_stock_data(symbol, start_date, end_date)
    data = prepare_data(data)

    if data.empty:
        print(f"No data found for the given date range: {start_date} to {end_date}")
        return

    create_candlestick_chart(data, chart_save_path)

    model = load_model(model_path)
    render = predict_trends(model, chart_save_path)

    render.save('prediction_result.png')
    print(f"Prediction result saved as prediction_result.png")

if __name__ == '__main__':
    main()

from IPython.display import Image
Image(filename='/content/prediction_result.png')

# Google Drive file ID
#file_id = "1LgaKNgXhv1rdqH08j9vxeDbcMb2YDCZ8"
file_id = "1qKUtpeAK8OxxIn1DPbK0KQgDZnz01Ig8"

# Construct the direct download URL
image_url = f"https://drive.google.com/uc?id={file_id}"
output_path = "video_input.mp4"

# Download the image
gdown.download(image_url, output_path, quiet=False)

from IPython.display import HTML, display
from base64 import b64encode


def show_preds_video(video_path, model_path, output_video_path='output_video.mp4', frame_skip=5, image_size=640, conf_threshold=0.25, iou_threshold=0.45):
    """
    Process video frames with YOLO model and annotate the frames.
    """
    cap = cv2.VideoCapture(video_path)  # Open the video file
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # Define the codec for the output video
    out = cv2.VideoWriter(output_video_path, fourcc, 20.0, (int(cap.get(3)), int(cap.get(4))))  # Create a VideoWriter object to save the output video

    frame_count = 0  # Initialize frame count

    while cap.isOpened():  # Loop through frames
        success, frame = cap.read()  # Read a frame from the video

        if success:
            if frame_count % frame_skip == 0:  # Process every nth frame, as specified by frame_skip
                model = YOLO(model_path)  # Load the YOLO model
                model.overrides['conf'] = conf_threshold  # Set the confidence threshold for predictions
                model.overrides['iou'] = iou_threshold  # Set the IoU threshold for Non-Maximum Suppression
                model.overrides['agnostic_nms'] = False  # NMS class-agnostic setting
                model.overrides['max_det'] = 1000  # Maximum number of detections per frame

                results = model.predict(frame)  # Perform inference on the frame
                annotated_frame = results[0].plot()  # Annotate the frame with detection results

                out.write(annotated_frame)  # Write the annotated frame to the output video
            else:
                out.write(frame)  # Write the original frame to the output video if not processed

            frame_count += 1  # Increment the frame count
        else:
            break  # Break the loop if no frame is read (end of video)

    cap.release()  # Release the video capture object
    out.release()  # Release the video writer object
    #cv2.destroyAllWindows()  # Close all OpenCV windows

    # Return the path to the saved annotated video
    return output_video_path

def display_video(video_path):
    """
    Display the video in the notebook.
    """
    display(HTML(f"""
    <video width="600" controls>
        <source src="{video_path}" type="video/mp4">
    </video>
    <a href="{video_path}" download>Download Video</a>
    """))

# Usage for video inference
video_path = '/content/video_input.mp4' 
model_path = 'foduucom/stockmarket-future-prediction'
output_video_path = show_preds_video(video_path, model_path)
display_video(output_video_path)

!pip install pyautogui

import cv2
import numpy as np
import pyautogui
from IPython.display import display, Image, clear_output
from ultralyticsplus import YOLO, render_result
import warnings
warnings.filterwarnings("ignore")

def load_model(model_path):
    model = YOLO(model_path)
    model.overrides['conf'] = 0.25
    model.overrides['iou'] = 0.45
    model.overrides['agnostic_nms'] = False
    model.overrides['max_det'] = 1000
    return model

def capture_and_predict_screen(model_path, frame_skip=5):
    """
    Capture the screen live, process frames with YOLO model, and display annotated frames.
    """
    model = load_model(model_path)  # Load the YOLO model

    frame_count = 0  # Initialize frame count

    while True:
        screenshot = pyautogui.screenshot()  # Capture the screen
        frame = np.array(screenshot)  # Convert the screenshot to a NumPy array
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)  # Convert the frame to RGB

        if frame_count % frame_skip == 0:  # Process every nth frame, as specified by frame_skip
            results = model.predict(frame, verbose=False)  # Perform inference on the frame
            annotated_frame = render_result(model=model, image=frame, result=results[0])  # Annotate the frame with detection results
            annotated_frame = np.array(annotated_frame)  # Ensure the annotated frame is a NumPy array
        else:
            annotated_frame = frame

        frame_count += 1  # Increment the frame count

        # Encode frame as JPEG to display in notebook
        _, img_encoded = cv2.imencode('.jpg', annotated_frame)
        img_bytes = img_encoded.tobytes()

        # Display frame in notebook
        display(Image(data=img_bytes))

        # Clear previous output
        clear_output(wait=True)

        # Break loop with keyboard interrupt
        try:
            key = cv2.waitKey(1)
            if key == 27:  # ESC key to exit
                break
        except KeyboardInterrupt:
            break

    cv2.destroyAllWindows()

# Execute function
model_path = 'foduucom/stockmarket-future-prediction'  
capture_and_predict_screen(model_path)