Initial Commit

INSTALL.md

@@ -0,0 +1,35 @@
+# Installation Guide
+This is being built with python 3.11.7. Try to use that version if possible.
+## Guide for this Project
+We are currently working on setting up the correct requirements.txt file for the entire interface. This will be updated soon!
+### Current Method
+1. Create a conda environment.
+    - conda create -n yolo8inter python=3.11.7
+2. Activate conda environment.
+    - conda activate yolo8inter
+3. Install PyTorch. The code below is specified for Windows, Conda, Python, & CUDA 11.8. If you need a different build, go to the [PyTorch website](https://pytorch.org/get-started/locally/).
+    - conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia
+4. Install Ultralytics.
+    - pip install ultralytics==8.0.186
+5. Install Other Requirements, like GRADIO. This is implemented but will be continually updated.
+    - pip install -r requirements.txt
+### Other Recommendations
+1. When you run any of the examples, at least 1 weights file (.pt) will be downloaded. It is reccomended to create a "weights" folder in the directory to keep track of these.
+
+## Directly from Ultralytics Github
+See below for a quickstart installation and usage example, and see the [YOLOv8 Docs](https://docs.ultralytics.com) for full documentation on training, validation, prediction and deployment.
+
+<details open>
+<summary>Install</summary>
+
+Pip install the ultralytics package including all [requirements](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml) in a [**Python>=3.8**](https://www.python.org/) environment with [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/).
+
+[![PyPI version](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Downloads](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics)
+
+```bash
+pip install ultralytics
+```
+
+For alternative installation methods including [Conda](https://anaconda.org/conda-forge/ultralytics), [Docker](https://hub.docker.com/r/ultralytics/ultralytics), and Git, please refer to the [Quickstart Guide](https://docs.ultralytics.com/quickstart).
+
+</details>

README.md

@@ -1,13 +1 @@
----
-title: YOLOv8 Interface
-emoji: 🌍
-colorFrom: purple
-colorTo: blue
-sdk: gradio
-sdk_version: 4.14.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+YOLOv8 Interface

RESOURCES.md

@@ -0,0 +1,7 @@
+# Resources
+## YOLOv8 Code & Documentation
+YOLOv8 is made by a company called Ultralytics. Most important info is on their Github, website, and youtube channel.
+1. [Ultralytics (YOLOv8) Github](https://github.com/ultralytics/ultralytics)
+2. [YOLOv8 Documentation Website](https://docs.ultralytics.com/)
+3. [Ultralytics Youtube Channel](https://www.youtube.com/ultralytics)
+3. Join the Ultralytics Discord server as well!

examples/gradio/basic.py

@@ -0,0 +1,15 @@
+import gradio as gr
+def update(name):
+    return f"Welcome to Gradio, {name}!"
+
+with gr.Blocks() as demo:
+    gr.Markdown("Start typing below and then click **Run** to see the output.")
+    with gr.Row():
+        inp = gr.Textbox(placeholder="What is your name?")
+        out = gr.Textbox()
+    btn = gr.Button("Run")
+    btn.click(fn=update, inputs=inp, outputs=out)
+
+if __name__== "__main__" :
+        # demo.queue().launch(share=True)
+        demo.queue().launch()

examples/gradio/tabbed.py

@@ -0,0 +1,40 @@
+import gradio as gr
+
+def welcome(name):
+    return f"Welcome to Gradio, {name}!"
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+    """
+    # Hello World!
+    Start typing below to see the output.
+    """)
+    inp = gr.Textbox(placeholder="What is your name?")
+    out = gr.Textbox()
+    inp.change(welcome, inp, out)
+
+tts_examples = [
+    "I love learning machine learning",
+    "How do you do?",
+]
+
+tts_demo = gr.load(
+    "huggingface/facebook/fastspeech2-en-ljspeech",
+    title=None,
+    examples=tts_examples,
+    description="Give me something to say!",
+    cache_examples=False
+)
+
+stt_demo = gr.load(
+    "huggingface/facebook/wav2vec2-base-960h",
+    title=None,
+    inputs="mic",
+    description="Let me try to guess what you're saying!",
+)
+
+demo = gr.TabbedInterface([tts_demo, stt_demo], ["Text-to-speech", "Speech-to-text"])
+
+if __name__ == "__main__":
+    demo.launch()
+

examples/tracking/track_webcam.py

@@ -0,0 +1,63 @@
+## Track but done as a stream from computer webcam
+from collections import defaultdict
+from ultralytics import YOLO
+import cv2
+import numpy as np
+
+# Load an official or custom model
+model = YOLO('yolov8n.pt')  # Load an official Detect model
+model = YOLO('yolov8n-seg.pt')  # Load an official Segment model
+model = YOLO('yolov8n-pose.pt')  # Load an official Pose model
+
+# Starts capturing video from webcam
+cap = cv2.VideoCapture(0)
+# Can be used for a video file as well
+# cap = cv2.VideoCapture("path/to/video.mp4")
+
+# Store the track history
+track_history = defaultdict(lambda: [])
+
+# Loop through the video frames
+while cap.isOpened():
+    # Read a frame from the video
+    success, frame = cap.read()
+
+    if success:
+        # Run YOLOv8 tracking on the frame, persisting tracks between frames
+        results = model.track(frame, persist=True, tracker="bytetrack.yaml")
+        
+        # Get the boxes and track IDs
+        boxes = results[0].boxes.xywh.cpu()
+        if results[0].boxes.id is not None:
+            track_ids = results[0].boxes.id.int().cpu().tolist()
+        else:
+            track_ids = []
+
+        # Visualize the results on the frame
+        annotated_frame = results[0].plot()
+
+        # Plot the tracks
+        for box, track_id in zip(boxes, track_ids):
+            x, y, w, h = box
+            track = track_history[track_id]
+            track.append((float(x), float(y)))  # x, y center point
+            if len(track) > 30:  # retain 90 tracks for 90 frames
+                track.pop(0)
+
+            # Draw the tracking lines
+            points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
+            cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)
+
+        # Display the annotated frame
+        cv2.imshow("YOLOv8 Tracking", annotated_frame)
+        
+        # Break the loop if 'q' is pressed
+        if cv2.waitKey(1) & 0xFF == ord("q"):
+            break
+    else:
+        # Break the loop if the end of the video is reached
+        break
+
+# Release the video capture object and close the display window
+cap.release()
+cv2.destroyAllWindows()

examples/tracking/track_youtube.py

@@ -0,0 +1,17 @@
+## Runs but can't be shown on lambda, if run on local machine a new window is opened to show the tracking
+## Is effective, but has no output. Maybe use for interface?
+
+from ultralytics import YOLO
+
+# Load an official or custom model
+model = YOLO('yolov8n.pt')  # Load an official Detect model
+model = YOLO('yolov8n-seg.pt')  # Load an official Segment model
+model = YOLO('yolov8n-pose.pt')  # Load an official Pose model
+
+# Perform tracking with the model
+## LNwODJXcvt4 is 6 mins, it runs at real time so the full length
+# results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)  # Tracking with default tracker
+# results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # Tracking with ByteTrack tracker, shows in new window
+# results = model.track(source="https://youtu.be/LNwODJXcvt4", show=False, tracker="bytetrack.yaml")  # Tracking with ByteTrack tracker, does not show
+results = model.track(source="https://www.youtube.com/watch?v=BZP1rYjoBgI&ab_channel=UndoTube", show=True, tracker="bytetrack.yaml")  # Shorter video, 30s
+print(results)

examples/training/train.py

@@ -0,0 +1,11 @@
+from ultralytics import YOLO
+
+if __name__== '__main__':
+    # Load a model
+    model = YOLO('yolov8n.yaml')  # build a new model from YAML
+    model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
+    model = YOLO('yolov8n.yaml').load('yolov8n.pt')  # build from YAML and transfer weights
+
+    # Train the model
+    # results = model.train(data='coco128.yaml', epochs=100, imgsz=640)   # train yolov8n on COCO128 for 100 epochs
+    results = model.train(data='coco128.yaml', epochs=2, imgsz=640)  # train yolov8n on COCO128 for 2 epochs

examples/training/wandb_train.py

@@ -0,0 +1,28 @@
+from ultralytics import YOLO
+from wandb.integration.ultralytics import add_wandb_callback
+import wandb
+
+if __name__ == "__main__":
+    wandb.login()
+    # Step 1: Initialize a Weights & Biases run
+    wandb.init(project="ultralytics", job_type="training")
+
+    # Step 2: Define the YOLOv8 Model and Dataset
+    model_name = "yolov8n"
+    dataset_name = "coco128.yaml"
+    model = YOLO(f"{model_name}.pt")
+
+    # Step 3: Add W&B Callback for Ultralytics
+    add_wandb_callback(model, enable_model_checkpointing=True)
+
+    # Step 4: Train and Fine-Tune the Model
+    model.train(project="ultralytics", data=dataset_name, epochs=2, imgsz=640)
+
+    # Step 5: Validate the Model
+    model.val()
+
+    # Step 6: Perform Inference and Log Results
+    model(["examples\\training\Images\Craig.jpg", "examples\\training\Images\WalterWhite.jpg"])
+
+    # Step 7: Finalize the W&B Run
+    wandb.finish()

interface/defaults.py

@@ -0,0 +1,3 @@
+import gradio as gr
+
+shared_theme = gr.themes.Base()

interface/detect_interface.py

@@ -0,0 +1,70 @@
+import gradio as gr
+from interface.detect_interface_methods import interface_detect
+from interface.defaults import shared_theme
+
+def build_detect_interface():
+    # Gradio Interface Code
+    with gr.Blocks(theme=shared_theme) as demo:
+        gr.Markdown(
+        """
+        # Image & Video Interface for YOLOv8
+        Upload your own image or video and watch YOLOv8 try to guess what it is!
+        """)
+        # Row for for input & output settings
+        with gr.Row() as file_settings:
+            # Allows choice for uploading image or video [for all]
+            file_type = gr.Radio(label="File Type",info="Choose 'Image' if you are uploading an image, Choose 'Video' if you are uploading a video",
+                                choices=['Image','Video'],value='Image',show_label=True,interactive=True,visible=True)
+        # Row for all inputs & outputs
+        with gr.Row() as inputs_outputs:
+            # Default input image: Visible, Upload from computer
+            input_im = gr.Image(sources=['upload','webcam','clipboard'],type='numpy',label="Input Image",
+                                show_download_button=True,show_share_button=True,interactive=True,visible=True)
+            # Default Boxed output image: Visible
+            output_box_im = gr.Image(type='numpy',label="Output Image",
+                                show_download_button=True,show_share_button=True,interactive=False,visible=True)
+            # Default input video: Not visible, Upload from computer
+            input_vid = gr.Video(sources=['upload','webcam'],label="Input Video",
+                                show_share_button=True,interactive=True,visible=False)
+            # Default Boxed output video: Not visible
+            output_box_vid = gr.Video(label="Output Video",show_share_button=True,visible=False)
+        
+        # List of components for clearing
+        clear_list = [input_im,output_box_im,input_vid,output_box_vid]
+        
+        # Row for start & clear buttons
+        with gr.Row() as buttons:
+            start_but = gr.Button(value="Start")
+            clear_but = gr.ClearButton(value='Clear All',components=clear_list,
+                    interactive=True,visible=True)
+
+        update_list = [input_im,output_box_im,input_vid,output_box_vid]
+        input_media = input_im
+        output_media = output_box_im
+
+        def change_input_type(file_type, input_media):
+            if file_type == 'Image':
+                input_media = input_im
+                output_media = output_box_im
+                return {
+                    input_im: gr.Image(visible=True),
+                    output_box_im: gr.Image(visible=True),
+                    input_vid: gr.Video(visible=False),
+                    output_box_vid: gr.Video(visible=False)
+                }
+            elif file_type == 'Video':
+                input_media = input_vid
+                output_media = output_box_vid
+                return {
+                    input_im: gr.Image(visible=False),
+                    output_box_im: gr.Image(visible=False),
+                    input_vid: gr.Video(visible=True),
+                    output_box_vid: gr.Video(visible=True)
+                }
+        
+        # When start button is clicked, the run_all method is called
+        start_but.click(interface_detect, inputs=[input_media], outputs=output_media)
+        # When these settings are changed, the change_file_type method is called
+        file_type.input(change_input_type, show_progress=True, inputs=[file_type, input_media], outputs=update_list)
+        
+    return demo

interface/detect_interface_methods.py

@@ -0,0 +1,15 @@
+
+import gradio as gr
+from ultralytics import YOLO
+import numpy as np
+
+def interface_detect(source):
+    # Load a pretrained YOLOv8n model
+    model = YOLO('yolov8n.pt')  # Load an official Detect model
+    if isinstance(source, gr.Video):
+        print("To be added")
+    elif isinstance(source, np.ndarray):
+        results = model.predict(source)
+        return results[0].plot()
+    else:
+        raise ValueError("Invalid source type")

interface/resources_interface.py

@@ -0,0 +1,18 @@
+import gradio as gr
+from interface.defaults import shared_theme
+
+def build_resources_interface():
+    # Gradio Interface Code
+    with gr.Blocks(theme=shared_theme) as demo:
+        gr.Markdown(
+        """
+        # Helpful Resources for YOLOv8
+        This page has a list of websites & guides to help you become a YOLOv8 Pro!
+        ## YOLOv8 Code & Documentation
+        YOLOv8 is made by a company called Ultralytics. Most important info is on their Github, website, and youtube channel.
+        1. [Ultralytics (YOLOv8) Github](https://github.com/ultralytics/ultralytics)
+        2. [YOLOv8 Documentation Website](https://docs.ultralytics.com/)
+        3. [Ultralytics Youtube Channel](https://www.youtube.com/ultralytics)
+        3. Join the Ultralytics Discord server as well!
+        """)
+    return demo

interface/train_interface.py

@@ -0,0 +1,58 @@
+import gradio as gr
+from interface.defaults import shared_theme
+from interface.train_interface_methods import interface_train, interface_login
+
+class TrainInterface():
+    def __init__(self):
+        self.demo = None
+        self.api_key = None
+        with gr.Blocks(theme=shared_theme) as demo:
+            gr.Markdown(
+            """
+            # Training Interface for YOLOv8
+            Train your own YOLOv8 model!
+            """)
+            
+            with gr.Row() as finetune_row:
+                is_finetune = gr.Checkbox(label="Finetune",info="Check this box if you want to finetune a model")
+                is_offical_pretrained = gr.Checkbox(label="Official",info="Check this box if you want to train an official model",visible=True,interactive=True,value=True)
+                custom_pretrained = gr.File(label="Pretrained Model Weights",file_count='single',type='binary',
+                                        file_types=['.pt'],visible=True,show_label=True,interactive=True)
+                offical_pretrained = gr.Dropdown(label="Pretrained Model",choices=["yolov8n.pt"],visible=True,interactive=True)
+            with gr.Row() as dataset_row:
+                is_official_dataset = gr.Checkbox(label="Official",info="Check this box if you want to use an official dataset",visible=True,interactive=True,value=True)
+                custom_dataset = gr.File(label="Custom Dataset",file_count='single',type='binary',
+                                        file_types=['.zip'],visible=True,show_label=True,interactive=True)
+                official_dataset = gr.Dropdown(label="Dataset",choices=["coco128"],visible=True,interactive=True)
+
+            # Row for start & clear buttons
+            with gr.Row() as buttons:
+                start_but = gr.Button(value="Start")
+            with gr.Accordion("Logger Options") as login_accordion:
+                use_logger = gr.Checkbox(label="Use Logger",info="Check this box if you want to use a logger",visible=True,interactive=True,value=False)
+                logger = gr.Radio(choices=['WANDB', 'ClearML', 'Tensorboard'],value='WANDB',show_label=True,interactive=True,visible=True,
+                                label="Logger",info="Choose which logger to use")
+                wandb_key = gr.Textbox(label="WANDB Key",placeholder="Enter WANDB Key",visible=True,interactive=True)
+                login_but = gr.Button(value="Login")
+            
+            def string_from_textbox(textbox):
+                self.api_key = textbox
+                
+            wandb_key.change(fn=string_from_textbox,inputs=[wandb_key],outputs=[])
+            
+            def logger_login(use_logger, logger):
+                if use_logger:
+                    interface_login(logger, [self.api_key])
+                else:
+                    gr.Warning("Not using logger, so no need to login")
+            
+            start_but.click(fn=interface_train,inputs=[is_finetune, official_dataset],outputs=[])
+            login_but.click(fn=logger_login,inputs=[use_logger,logger],outputs=[])
+            self.demo = demo
+            
+    def get_interface(self):
+        return self.demo
+
+if __name__== "__main__" :
+    demo = TrainInterface().get_interface()
+    demo.queue().launch()

interface/train_interface_methods.py

@@ -0,0 +1,56 @@
+import gradio as gr
+from ultralytics import YOLO
+from wandb.integration.ultralytics import add_wandb_callback
+import wandb
+
+def interface_login(logger, args):
+    if logger == 'WANDB':
+        result = False
+        wandb_key = args[0]
+        if (wandb_key is not None) & isinstance(wandb_key, str):
+            try:
+                result = wandb.login(key=wandb_key,relogin=True,timeout=15)
+            except:
+                gr.Warning("Issue with the WANDB key")
+        else:
+            gr.Warning("Issue with the WANDB key")
+        if result:
+            gr.Info("Logged in to WANDB")
+        else:
+            gr.Warning("Failed to log in to WANDB")
+    elif logger == 'ClearML':
+        pass
+    elif logger == 'Tensorboard':
+        pass
+
+def interface_finetune():
+    # Load a pretrained YOLOv8n model
+    model = YOLO('yolov8n.pt')  # Load an official Detect model
+    return model
+    
+def interface_train(is_fintune=False, dataset=None, epochs=2, imgsz=640):
+    model = YOLO('yolov8n.yaml')
+    if is_fintune:
+        model = interface_finetune()
+    results = model.train(data=dataset, epochs=epochs, imgsz=imgsz)
+    
+def interface_train_wandb(project_name, model_name, dataset_name, epochs=2, imgsz=640):
+    # Step 1: Initialize a Weights & Biases run
+    wandb.init(project=project_name, job_type="training")
+
+    model = YOLO(f"{model_name}.pt")
+
+    # Step 3: Add W&B Callback for Ultralytics
+    add_wandb_callback(model, enable_model_checkpointing=True)
+
+    # Step 4: Train and Fine-Tune the Model
+    model.train(project=project_name, data=dataset_name, epochs=epochs, imgsz=imgsz)
+
+    # Step 5: Validate the Model
+    model.val()
+
+    # # Step 6: Perform Inference and Log Results
+    # model(["Images\Craig.jpg", "Images\WalterWhite.jpg"])
+
+    # Step 7: Finalize the W&B Run
+    wandb.finish()

main_interface.py

@@ -0,0 +1,32 @@
+# Abstracted file for running the interface. Can run from command line or through debugger.
+
+from interface.detect_interface import build_detect_interface
+from interface.train_interface import TrainInterface
+from interface.resources_interface import build_resources_interface
+import gradio as gr
+from interface.defaults import shared_theme
+import wandb
+
+def build_main_interface():
+    detect = build_detect_interface()
+    train = TrainInterface().get_interface()
+    resources = build_resources_interface()
+    
+    with gr.Blocks(title="YOLOv8 Interface",theme=shared_theme) as demo:
+        gr.Markdown(
+        """
+        # YOLOv8 Interface
+        Choose between the Detect and Train interfaces.
+        """)
+        gr.TabbedInterface(interface_list=[detect, train, resources], 
+                            tab_names=["Detect", "Train", "Resources"],
+                            theme=shared_theme,
+                            analytics_enabled=True)
+        
+    return demo
+
+if __name__== "__main__" :
+    # run_main_interface()
+    demo = build_main_interface()
+    demo.queue().launch()
+    demo.integrate(wandb=wandb)

requirements.txt

@@ -0,0 +1,8 @@
+# Usage: pip install -r requirements.txt
+# If issues: pip --no-cache-dir install -r requirements.txt
+lapx
+pafy
+youtube_dl==2020.12.2
+gradio
+clearml>=1.2.0
+wandb