updated code

.gitignore

@@ -0,0 +1,2 @@
+venv
+__pycache__

app.py

@@ -0,0 +1,67 @@
+import gradio as gr
+from helper import *
+from prompts_and_chema import *
+
+def full_chat_pipeline(user_query, openai_key):
+    try:
+        # ✅ Step 1: Set the OpenAI API key
+        openai.api_key = openai_key
+
+        # Step 1: Get intent from first GPT call
+        raw_response = chat_with_gpt(intent_system_prompt, user_query, use_schema=True, schema=intent_output_schema )
+        # print(f"raw_response: {raw_response}")
+
+        intents = json.loads(raw_response) if isinstance(raw_response, str) else raw_response
+        # print(f"Intents: {intents}")
+
+        # Step 2: Format prompt with detected intent
+        loaded_texts = load_intent_texts(intents, get_txt_files)
+        selected_intents_str = ', '.join(intents.get("intents", []))
+        context_str = '\n\n'.join(f"{k}:\n{v}" for k, v in loaded_texts.items())
+        formatted_prompt = f'''
+
+        User query: {user_query}
+
+        Selected Intents: {selected_intents_str}
+
+        Context: {context_str}
+
+        '''
+
+        # Step 3: Get final answer from second GPT call
+        final_response = chat_with_gpt(get_answer_system_prompt, formatted_prompt)
+        # print("Final Response:", final_response)
+
+        return f"{selected_intents_str}", f"{final_response}"
+
+    except Exception as e:
+        return f"Error while classifying intents: {str(e)}", f"Error while generating response: {str(e)}"
+
+
+# Gradio UI
+with gr.Blocks(title="Degirum LLM") as demo:
+    gr.Markdown("## Degirum LLM")
+    gr.Markdown("Ask questions...")
+    # 🔑 OpenAI Key on top
+    openai_key = gr.Textbox(label="🔑 OpenAI API Key", placeholder="Enter your OpenAI API key...", type="password")
+
+    # Row with query input and intent output side by side
+    with gr.Row():
+        user_query = gr.Textbox(label="💬 Query", placeholder="Type your question here...", lines=3)
+        intent_output = gr.Textbox(label="🧠 Classified Intents", placeholder="will get answer by AI", lines=3, interactive=False)
+
+    # 🚀 Submit Button
+    submit_btn = gr.Button("🚀 Submit", variant="primary")
+
+    # 🤖 AI Response at the bottom
+    response_output = gr.Textbox(label="🤖 Full AI Response", lines=10, interactive=False)
+
+    submit_btn.click(
+        fn=full_chat_pipeline,
+        inputs=[user_query, openai_key],
+        outputs=[intent_output, response_output]
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

helper.py

@@ -0,0 +1,67 @@
+import openai
+import os
+import json
+
+def chat_with_gpt(system_prompt, user_query, use_schema=False, schema=None):
+    """
+    Function to interact with OpenAI's GPT model
+
+    Args:
+        system_prompt (str): The system prompt to set the context
+        user_query (str): The user's question or prompt
+
+    Returns:
+        str: The model's response
+    """
+    try:
+        if use_schema:
+          response = openai.ChatCompletion.create(
+              model="gpt-4o",
+              messages=[
+                  {"role": "system", "content": system_prompt},
+                  {"role": "user", "content": user_query}
+              ],
+              response_format={
+                                "type": "json_schema",
+                                "json_schema": {
+                                    "name": "classify-intents",
+                                    "schema": schema,
+                                    "strict": True}
+                                    },
+          )
+          return response.choices[0].message.content
+        else:
+          response = openai.ChatCompletion.create(
+              model="gpt-4o",
+              temperature = 0.6,
+              messages=[
+                  {"role": "system", "content": system_prompt},
+                  {"role": "user", "content": user_query}
+              ],
+          )
+          return response.choices[0].message.content
+    except Exception as e:
+        return f"An error occurred: {str(e)}"
+    
+def load_intent_texts(intents, get_txt_files):
+    """
+    Load text content for a list of intents based on a mapping of intent to file names.
+
+    Args:
+        intent_list (list): List of detected intents.
+        get_txt_files (dict): Mapping of intent names to file paths.
+
+    Returns:
+        dict: Dictionary with intent names as keys and file content as values.
+    """
+    loaded_texts = {}
+    intent_list = intents.get("intents", [])
+    for intent in intent_list:
+        filename = get_txt_files.get(intent)
+        if filename:
+            try:
+                with open(filename, "r") as f:
+                    loaded_texts[intent] = f.read()
+            except FileNotFoundError:
+                loaded_texts[intent] = f"[ERROR] File '{filename}' not found."
+    return loaded_texts

prompts_and_chema.py

@@ -0,0 +1,88 @@
+intent_output_schema = {
+      "type": "object",
+      "properties": {
+        "intents": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": ["hello_world_of_pysdk", "single_model_inference", "running_yolo_models", "model_pipelining", "class_filtering", "overlay_effects", "running_inference_on_video", "person_re_identification_or_extracting_embeddings", "zone_counting", "custom_video_source", "not_supported"]
+          },
+        }
+      },
+      "required": ["intents"],
+      "additionalProperties": False
+  }
+
+intent_system_prompt = '''
+Degirum PySDK is a python based SDK that is built to support AI inference of computer vision models on multiple AI accelerators like Intel Openvino, Hailo, Memryx, N2X etc. The software stack provides unified way to run inference on any model across our model zoo or from a local model zoo and perform post processing over it.
+
+I will provide you with a user query and your job is to classify the intent, the query belongs to. I have 10 intents. Each intent comprises of a feature or function that degirum supports.
+
+Intents:
+
+1. hello_world_of_pysdk: Basic setup, setting up account on DeGirum AI hub, generate dg_token, and run a simple example where you load a model from degirum model zoo, and just pass an example image and see output. Any question asked about setup, what is PySDK, generating tokens or starting with pysdk, a beginner friendly example, then select this intent.
+
+2. single_model_inference: Running an image on a single model either from degirum AI Hub model zoo or local model zoo. A basic example where you pass an image to the model and get results. It can be a segmentation, object detection, classification or pose estimation model and result return type will be different for each. Any question on simple example to run a single AI model on images only, choosing inference device, display and printing results etc should fall under this intent.
+
+3. running_yolo_models: This intent includes running different flavours of yolo models like yolo v5, v8, v11 - object detection, pose estimation, classification etc. This intent is similar to above intent but is specific to yolo models. It also includes selecting different inference option like cloud or local and visualize the output on images. If user asks about a use-case on images, for eg. face detection or car detection etc which you think can be fulfilled using any of the above models across any flavour (coco dataset), select this intent.
+
+4. model_pipelining: This intent includes running two or multiple models one after the other in pipeline way to achieve something. For eg. for emotion classification usecase, we first run face detection model to extract faces and then run emotion classification model over it. So any query or usecase in the query is related to running two or models in pipeline mode, select this intent.
+
+5. class_filtering: If a model has multiple classes but you only want to detect a particular class, there is a way to do it in degirum pysdk. So any question or query where user wants to detect only a particular set of classes out of all the classes model is trained on, select this intent. For eg. someone is using coco model but wants to detect only person and car.
+
+6. overlay_effects: Degirum pysdk supports multiple overlay effects after we get results from the model like blurring the detected object, changing colour of the bounding box, changing size and position of the labels, changing font or showing probabilities, bounding box thickness etc. So any such query or use-case where some kind of overlay effects is required, use this intent.
+
+7. running_inference_on_video: This is similar to intent #2 and #3 where we show running model inference on images but here we show inference on videos. Video can be saved video file, webcam stream or RTSP URL. So any query about running inference on live camera feed or saved video files, we should select this intent. For most real world use-cases, we will be running inference on videos but while prototyping user may need to test on images. So choose between this intent and intent 2 and 3 carefully.
+
+8. person_re_identification_or_extracting_embeddings : There are some use-cases where user may need to extract embeddings from the image and store it or use it to calculate similarity etc. For eg. In person re-identification usecase, we extract face embeddings of a user and match it with the stored embeddings to identify if this is the same person. If user's query or use-case includes these kind of mechanism, select this intent.
+
+9. zone_counting: Some use-cases includes selecting ROI for detection and then counting objects - for eg. counting number of people in a zone etc. For this, we have a specific function in DeGirum which allows you to draw a polygon for ROI and then count object (whichever class you specify) and returns that. If user query falls under this use-case, select this intent.
+
+10. custom_video_source: Sometimes user may want to modify the incoming video source (may it be live stream like RTSP or saved video file) and apply some pre-processing to it like rotating, cropping, changing colour channels etc maybe to enhance detection. DeGirum PySDK allows user to modify incoming video stream before passing to model predictions. So any use-case or query related to modifying video source falls under this intent.
+
+11. not_supported - Anything outside of the above intents will be something that degirum pysdk doesnt support. Dont try to forcibly put the query under any intent, if we dont support something its better to let user know this is not supported. This intent is specifically for avoiding hallucinations and throwing out made-up info to user even if we dont support that. So for any query about a feature which is not covered in above intents, select this intent.
+
+Any question or query that I ask, analyse and think deeper. Try to identify the flow and think about all the intents applicable. Try to generalise the query and understand which intents are applicable. Dont focus on answering the query just select the intents from above list and return the intents that you feel are relevant. As I said, try to generalise the query and identify under which category this use-case falls into. If the feature is not listed above, return #11 intent which is not supported.
+
+Upon asking question, just return the intent name, nothing else. Dont focus on answering the query. Just try to generalise the question or query and return the intents that match.
+
+Example of chain of thought:
+
+User: I want to blur the faces of females in the video stream
+
+Think: It will require running a model that can detect faces. Then user will want to run a classification model to classify the gender of the detected faces.
+And then user will want to apply some overlay effects to the video stream to blur the faces of females.
+So it will require running two models one after the other. Hence it will require model pipelining. And also overlay effects to blur the faces.
+
+Hence the intents applicable here are #4 model_pipelining and #6 overlay_effects.
+Especially pay attention if user request requires using multiple models or model pipelines. Analyse the use-case of the user and think about the implementation to
+identify the intents.
+
+Response:
+{{
+  "intents": ["model_pipelining", "overlay_effects"]
+}}
+Only return the list of intent names based on provided schema in JSON format. If there in only one intent, return it as a list.
+
+'''
+
+get_answer_system_prompt = '''
+Degirum PySDK is a python based SDK that is built to support AI inference of computer vision models on multiple AI accelerators like Intel Openvino, Hailo, Memryx, N2X etc. The software stack provides unified way to run inference on any model across our model zoo or from a local model zoo and perform post processing over it. We are building a system to generate answer for our users questions on PySDK. Based on user's query, we have a system that identifies which examples or part of documentation can help generate answer for user query.
+
+So I will provide you example codes with comments and documentations, your job is to analyse the examples and understand it conceptually. Based on that, identify what user is looking for and generate code accordingly. User's request may not be exact, but it can be derived from the example code that I pass to you as reference. Also, you can use commonly used opencv functions or other python frameworks to help satisfy user request, but dont try to make up any degirum PySDK functions which are not in the example references. Try to use PySDK code as much as possible. Try to generalize user's question to help better.
+
+I will attach example references and ask users question, your job is to generate a response along with code as instructed above. '''
+
+get_txt_files = {
+    "hello_world_of_pysdk": "/content/text_files/001_quick_start.txt",
+    "single_model_inference": "/content/text_files/object_detection_image.txt",
+    "running_yolo_models": "/content/text_files/002_yolov8.txt",
+    "model_pipelining": "/content/text_files/007_model_pipelining.txt",
+    "class_filtering": "/content/text_files/object_detection_class_filtering.txt",
+    "overlay_effects": "/content/text_files/013_overlay_effects.txt",
+    "running_inference_on_video": "/content/text_files/object_detection_video_stream.txt",
+    "person_re_identification_or_extracting_embeddings": "/content/text_files/014_person_reid.txt",
+    "zone_counting": "/content/text_files/009_zone_counting.txt",
+    "custom_video_source": "/content/text_files/016_custom_video_source.txt",
+}
+

text_files/001_quick_start.txt

@@ -0,0 +1,156 @@
+### DeGirum PySDK Tutorial for Hailo8L/HAILO8
+In this notebook, we illustrate the main features of PySDK and how it can be used to quickly develop edge AI applications using the `Hailo8L/HAILO8` accelerator. See [Setup Instructions for PySDK Notebooks](../README.md#setup-instructions-for-pysdk-notebooks). 
+
+DeGirum's PySDK provides simple APIs to run AI model inference. In general, there are three steps in running an AI model:
+1. Loading model using `degirum.load_model` method
+2. Running inference on an input using the `model.predict` method 
+3. Visualizing inference results using the `results.image_overlay` method
+
+--------------------------------------------------------------------------------
+
+# import degirum and degirum_tools
+import degirum as dg, degirum_tools
+
+inference_host_address = "@local"
+zoo_url = 'degirum/hailo'
+token=''
+device_type='HAILORT/HAILO8L'
+
+# set model name, and image source
+model_name = "yolov8n_relu6_coco--640x640_quant_hailort_hailo8l_1"
+image_source='../assets/ThreePersons.jpg'
+
+# load AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type,    
+)
+
+# perform AI model inference on given image source
+print(f" Running inference using '{model_name}' on image source '{image_source}'")
+inference_result = model(image_source)
+
+# print('Inference Results \n', inference_result)  # numeric results
+print(inference_result)
+print("Press 'x' or 'q' to stop.")
+
+# show results of inference
+with degirum_tools.Display("AI Camera") as output_display:
+    output_display.show_image(inference_result.image_overlay)
+
+--------------------------------------------------------------------------------
+
+#### Running Inference on Video Stream
+- The `predict_stream` function in `degirum_tools` provides a powerful and efficient way to perform AI inference on video streams in real-time. It processes video frames sequentially and returns inference results frame by frame, enabling seamless integration with various video input sources.
+- The code below shows how to use `predict_stream` on a video file.
+
+--------------------------------------------------------------------------------
+
+import degirum as dg, degirum_tools
+
+inference_host_address = "@local"
+zoo_url = 'degirum/hailo'
+token=''
+device_type='HAILORT/HAILO8L'
+
+model_name = "yolov8n_relu6_coco--640x640_quant_hailort_hailo8l_1"
+video_source = '../assets/Traffic.mp4'
+
+# load AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type
+)
+
+with degirum_tools.Display("AI Camera") as output_display:
+    for inference_result in degirum_tools.predict_stream(model, video_source):
+        output_display.show(inference_result)
+
+--------------------------------------------------------------------------------
+
+### Listing Models 
+You can explore the models available using `degirum.list_models()` method.
+
+--------------------------------------------------------------------------------
+
+import degirum as dg, degirum_tools
+
+inference_host_address = "@local"
+zoo_url = 'degirum/hailo'
+token=''
+device_type=['HAILORT/HAILO8L']
+
+model_list=dg.list_models(
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type
+)
+for index, model_name in enumerate(model_list):
+    print(index, model_name)
+
+--------------------------------------------------------------------------------
+
+### Switch to local model zoo
+In this repo, we provide a `models` folder with a couple of example models. You can use the code block as a reference to run models from a local folder.
+
+--------------------------------------------------------------------------------
+
+import degirum as dg
+
+inference_host_address = "@local"
+zoo_url = '../models'
+token=''
+device_type='HAILORT/HAILO8L'
+
+model_list = dg.list_models(
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type 
+)
+
+for model_name in model_list.keys():
+    print(model_name)
+
+--------------------------------------------------------------------------------
+
+import degirum as dg, degirum_tools
+
+inference_host_address = "@local"
+zoo_url = '../models'
+token=''
+device_type='HAILORT/HAILO8L'
+
+# set model name, inference host address, zoo url, token, and image source
+model_name = "yolov8n_relu6_coco--640x640_quant_hailort_hailo8l_1"
+image_source='../assets/ThreePersons.jpg'
+
+# load AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=inference_host_address,
+    zoo_url='../models',
+    token=token,
+    device_type=device_type
+)
+
+# perform AI model inference on given image source
+print(f" Running inference using '{model_name}' on image source '{image_source}'")
+inference_result = model(image_source)
+
+# print('Inference Results \n', inference_result)  # numeric results
+print(inference_result)
+print("Press 'x' or 'q' to stop.")
+
+# show results of inference
+with degirum_tools.Display("AI Camera") as output_display:
+    output_display.show_image(inference_result)
+
+--------------------------------------------------------------------------------

text_files/002_yolov8.txt

@@ -0,0 +1,51 @@
+### Running YOLO Models on Hailo
+This notebook demonstrates running different flavors of YOLO models (e.g., image classification, object detection, pose estimation, and segmentation) 
+using a unified codebase with DeGirum PySDK. Key features include:
+
+- Unified handling of YOLO model variants with minimal changes to the code.
+- Flexible selection of inference host (cloud or local) and model zoo location.
+- Seamless output visualization, regardless of the specific YOLO model used.
+
+Simply uncomment a model of your choice, provide the necessary configurations, and run the code block 
+to perform inference and visualize the results.
+
+--------------------------------------------------------------------------------
+
+import degirum as dg, degirum_tools
+
+inference_host_address = "@local"
+zoo_url = 'degirum/hailo'
+token=''
+device_type=['HAILORT/HAILO8L']
+
+# choose a model to run inference on by uncommenting one of the following lines
+model_name = "yolov8n_relu6_coco--640x640_quant_hailort_hailo8l_1"
+# model_name = "yolov8n_relu6_coco_pose--640x640_quant_hailort_hailo8l_1"
+# model_name = "yolov8n_relu6_coco_seg--640x640_quant_hailort_hailo8l_1"
+# model_name = "yolov8s_silu_imagenet--224x224_quant_hailort_hailo8l_1"
+
+# choose image source
+image_source = "../assets/ThreePersons.jpg"
+
+# load AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type
+)
+
+# perform AI model inference on given image source
+print(f" Running inference using '{model_name}' on image source '{image_source}'")
+inference_result = model(image_source)
+
+# print('Inference Results \n', inference_result)  # numeric results
+print(inference_result)
+print("Press 'x' or 'q' to stop.")
+
+# show results of inference
+with degirum_tools.Display("AI Camera") as output_display:
+    output_display.show_image(inference_result.image_overlay)
+
+--------------------------------------------------------------------------------

text_files/007_model_pipelining.txt

@@ -0,0 +1,54 @@
+### Pipelining Two Models
+This notebook is an example of how to use DeGirum PySDK to do AI inference of a video file using two AI models: face detection and gender classification. The face detection model is run on the image and the results are then processed by the gender classification model, one face at a time. Combined result is then displayed.
+
+--------------------------------------------------------------------------------
+
+import degirum as dg, degirum_tools
+
+inference_host_address = "@local"
+zoo_url = 'degirum/hailo'
+token=''
+device_type=['HAILORT/HAILO8L']
+
+# specify model names
+face_det_model_name = "yolov8n_relu6_face--640x640_quant_hailort_hailo8l_1"
+gender_cls_model_name = "yolov8n_relu6_fairface_gender--256x256_quant_hailort_hailo8l_1"
+
+# specify video source
+video_source = "../assets/faces_and_gender.mp4"
+
+# Load face detection and gender detection models
+face_det_model = dg.load_model(
+    model_name=face_det_model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token='',
+    device_type=device_type,
+    overlay_color=[(255,255,0),(0,255,0)]    
+)
+
+gender_cls_model = dg.load_model(
+    model_name=gender_cls_model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token='',
+    device_type=device_type,
+)
+
+# Create a compound cropping model with 20% crop extent
+crop_model = degirum_tools.CroppingAndClassifyingCompoundModel(
+    face_det_model, 
+    gender_cls_model, 
+    30.0
+)
+
+# run AI inference on video stream
+inference_results = degirum_tools.predict_stream(crop_model, video_source)
+
+# display inference results
+# Press 'x' or 'q' to stop
+with degirum_tools.Display("Faces and Gender") as display:
+    for inference_result in inference_results:
+        display.show(inference_result.image_overlay)
+
+--------------------------------------------------------------------------------

text_files/009_zone_counting.txt

@@ -0,0 +1,64 @@
+### Interactive Zone-Based Object Counting with DeGirum PySDK
+This script demonstrates how to perform object detection and counting within specific zones of interest using DeGirum PySDK. The key features include:
+
+- Model-Based Object Detection: Utilizes the YOLOv8 model to detect objects such as cars, motorbikes, and trucks from a video stream.
+- Zone-Based Counting: Counts objects within user-defined polygonal zones, defined as a list of coordinates.
+- Interactive Zone Adjustment: The zones of interest can be interactively adjusted in real-time using the mouse within the display window, providing flexibility to adapt to changing scenarios.
+- Customizable Output: Supports filtering specific object classes for counting and displays results per class.
+- Stream Processing: Processes video streams, displaying both the detected objects and zone-based analytics in a dedicated window.
+
+Simply define your zones, select the classes to track, and specify the video source to get started. This script is ideal for applications such as traffic monitoring, crowd analysis, and zone-specific surveillance.
+
+--------------------------------------------------------------------------------
+
+import degirum as dg, degirum_tools
+
+
+inference_host_address = "@local"
+zoo_url = "degirum/hailo"
+token = ''
+device_type = "HAILORT/HAILO8L"
+
+# set the model name and video source
+model_name = 'yolov8n_relu6_coco--640x640_quant_hailort_hailo8l_1'
+video_source = '../assets/Traffic.mp4'
+
+# define the zones of interest
+polygon_zones = [
+    [[265, 260], [730, 260], [870, 450], [120, 450]],
+    [[400, 100], [610, 100], [690, 200], [320, 200]],
+]
+
+# define class list and display options
+class_list = ["car", "motorbike", "truck"]
+per_class_display = True
+window_name="AI Camera"
+
+# load model
+model = dg.load_model(
+    model_name=model_name, 
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    overlay_color=[(255,0,0)],
+    output_class_set = set(class_list)
+)
+
+# create zone counter
+zone_counter = degirum_tools.ZoneCounter(
+        polygon_zones,        
+        class_list=class_list,
+        per_class_display=per_class_display,
+        triggering_position=degirum_tools.AnchorPoint.CENTER,
+        window_name=window_name,  # attach display window for interactive zone adjustment
+)
+
+# attach zone counter to model
+degirum_tools.attach_analyzers(model, [zone_counter])
+
+# run inference and display results
+with degirum_tools.Display(window_name) as display:
+    for inference_result in degirum_tools.predict_stream(model, video_source,):
+        display.show(inference_result)
+
+--------------------------------------------------------------------------------

text_files/013_overlay_effects.txt

@@ -0,0 +1,238 @@
+# Image overlay properties using DeGirum PySDK
+In this notebook, we illustrate the different image overlay properties of DeGirum PySDK and how it can be used to display inference results with different types of formatting.
+
+--------------------------------------------------------------------------------
+
+import degirum as dg
+import degirum_tools
+
+# Define variables
+model_name = 'yolov8n_coco--640x640_quant_hailort_hailo8l_1'
+zoo_url = 'degirum/hailo'
+inference_host_address = '@local'
+device_type = 'HAILORT/HAILO8L'
+token = ''
+image_source = '../assets/dog_and_person.jpg'
+
+--------------------------------------------------------------------------------
+
+## Load Model
+
+`model` object in DeGirum PySDK has a set of properties and methods that handles inference lifecycle tasks and also provides properties for overlay customization seperately. In this notebook, we will go through some of the examples reflecting overlay properties in PySDK.
+
+Required arguments for `dg.load_model` are model name, host address, model zoo url, cloud token and device type.
+
+--------------------------------------------------------------------------------
+
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type
+)
+
+# perform AI model inference on given image source
+print(f" Running inference using '{model_name}' on image source '{image_source}'")
+inference_result = model(image_source)
+
+print('\n Inference Results \n', inference_result)  # numeric results
+
+# show results of inference
+with degirum_tools.Display("AI Camera") as output_display:
+    output_display.show_image(inference_result)
+
+--------------------------------------------------------------------------------
+
+### Show Class Labels
+- Displays the class names (e.g., "person", "car") on top of detected objects in the overlay. Default value is `True`. Set to `False` to hide labels.
+
+--------------------------------------------------------------------------------
+
+# load AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type,
+    overlay_show_labels = False # set to True to show labels on the image 
+)
+
+# perform AI model inference on given image source
+print(f" Running inference using '{model_name}' on image source '{image_source}'")
+inference_result = model(image_source)
+
+print('\n Inference Results \n', inference_result)  # numeric results
+
+# show results of inference
+with degirum_tools.Display("AI Camera") as output_display:
+    output_display.show_image(inference_result)
+
+--------------------------------------------------------------------------------
+
+### Show Class Probabilities
+- Shows the prediction confidence score (e.g., 0.95) next to each detected label. Default value is `False`
+
+--------------------------------------------------------------------------------
+
+# load AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type,
+    overlay_show_probabilities = True
+)
+
+# perform AI model inference on given image source
+print(f" Running inference using '{model_name}' on image source '{image_source}'")
+inference_result = model(image_source)
+
+print('\n Inference Results \n', inference_result)  # numeric results
+
+# show results of inference
+with degirum_tools.Display("AI Camera") as output_display:
+    output_display.show_image(inference_result)
+
+--------------------------------------------------------------------------------
+
+### Set Font Scale
+- Adjusts the size of the text displayed on the overlay (labels and probabilities). Its value is of type `float`, default being 1.0
+
+--------------------------------------------------------------------------------
+
+# load AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type,
+    overlay_font_scale = 3.2
+)
+
+# perform AI model inference on given image source
+print(f" Running inference using '{model_name}' on image source '{image_source}'")
+inference_result = model(image_source)
+
+print('\n Inference Results \n', inference_result)  # numeric results
+
+# show results of inference
+with degirum_tools.Display("AI Camera") as output_display:
+    output_display.show_image(inference_result)
+
+--------------------------------------------------------------------------------
+
+### Set Bounding Box Thickness
+- Changes the thickness of the boxes drawn around detected objects. Its value is of type `float`, default being 3.0
+
+--------------------------------------------------------------------------------
+
+# load AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type,
+    overlay_line_width = 5
+)
+
+# perform AI model inference on given image source
+print(f" Running inference using '{model_name}' on image source '{image_source}'")
+inference_result = model(image_source)
+
+print('\n Inference Results \n', inference_result)  # numeric results
+
+
+# show results of inference
+with degirum_tools.Display("AI Camera") as output_display:
+    output_display.show_image(inference_result)
+
+--------------------------------------------------------------------------------
+
+### Set Overlay Box Color
+- Defines the color of bounding boxes using RGB format. Default value is Black RGB(0,0,0).
+- overlay_color can also be `(list[tuple[int,int,int]])`: Palette of RGB colors for drawing results; each tuple is an (R, G, B) value.
+Color for a detection is chosen as `overlay_color[class_id % len(overlay_color)]` (class-ID modulo palette length).
+
+--------------------------------------------------------------------------------
+
+# load AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type,
+    overlay_color = [(255, 0, 0), (0, 255, 0), (0,0,255)] # red and green and blue colors
+)
+
+# perform AI model inference on given image source
+print(f" Running inference using '{model_name}' on image source '{image_source}'")
+inference_result = model(image_source)
+
+print('\n Inference Results \n', inference_result)  # numeric results
+
+
+# show results of inference
+with degirum_tools.Display("AI Camera") as output_display:
+    output_display.show_image(inference_result)
+
+--------------------------------------------------------------------------------
+
+### Set Overlay Transparency
+- Controls the transparency of the overlay bounding boxes that appears over the image. This value is a `float` ranging from 0 to 1, where 1 represents full opacity and 0 indicates near invisibility. Default value is 1.0
+
+--------------------------------------------------------------------------------
+
+# load AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type,
+    overlay_alpha = 0.5 # 50% transparent overlay
+)
+
+# perform AI model inference on given image source
+print(f" Running inference using '{model_name}' on image source '{image_source}'")
+inference_result = model(image_source)
+
+print('\n Inference Results \n', inference_result)  # numeric results
+
+# show results of inference
+with degirum_tools.Display("AI Camera") as output_display:
+    output_display.show_image(inference_result)
+
+--------------------------------------------------------------------------------
+
+### Blur Detected Objects
+- Applies a blur effect to each detected object in the overlay. You can specify particular object classes to blur, or use `"all"` to blur every detected object. The default value is `None`.
+
+--------------------------------------------------------------------------------
+
+# load AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type,
+    overlay_blur = "dog"
+)
+
+# perform AI model inference on given image source
+print(f" Running inference using '{model_name}' on image source '{image_source}'")
+inference_result = model(image_source)
+
+print('\n Inference Results \n', inference_result)  # numeric results
+
+# show results of inference
+with degirum_tools.Display("AI Camera") as output_display:
+    output_display.show_image(inference_result)
+
+--------------------------------------------------------------------------------

text_files/014_person_reid.txt

@@ -0,0 +1,182 @@
+# Person Re-identification using PySDK
+This notebook demonstrates Person Re-Identification (Re-ID) using PySDK. Re-ID focuses on recognizing and matching people across different camera views based on their unique appearance, like clothing and body shape.
+
+The basic pipeline works like this:
+1. Detect people in the image using a person detection model.
+2. Crop each detected person using the bounding box coordinates.
+3. Apply the Person Re-ID model to the cropped images to extract the embeddings which can further be used to identify and match individuals across different images or camera views.
+
+--------------------------------------------------------------------------------
+
+import degirum as dg, degirum_tools
+
+inference_host_address = "@local"
+zoo_url = "degirum/hailo"
+token = '' 
+device_type = "HAILORT/HAILO8L"
+
+# Person detection model name 
+person_det_model_name = "yolov8n_relu6_person--640x640_quant_hailort_hailo8l_1"
+
+# load AI model
+person_det_model = dg.load_model(
+    model_name=person_det_model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type
+)
+
+# Choose the Person reid model name 
+person_reid_model_name = "osnet_x1_0_person_reid--256x128_quant_hailort_hailo8l_1"
+# person_reid_model_name = "repvgg_a0_person_reid--256x128_quant_hailort_hailo8l_1" 
+
+# load AI model
+person_reid_model = dg.load_model(
+    model_name=person_reid_model_name,
+    inference_host_address=inference_host_address,
+    zoo_url=zoo_url,
+    token=token,
+    device_type=device_type
+)
+
+--------------------------------------------------------------------------------
+
+#### Let's walk through a practical example of person re-identification.<br> 
+
+## Example Scenario
+We use two sets of images:
+- **Set A:** Same person, different views.
+- **Set B:** Another individual, different views.
+
+The goal is to verify whether the ReID model can:
+
+- Correctly match all images in Set A or B as the same person.
+- Correctly distinguish Set B as a different person from Set A.
+
+This simulates a real-world scenario where the model must recognize individuals across different camera views and lighting conditions.
+
+--------------------------------------------------------------------------------
+
+# Utility function for displaying images
+
+import matplotlib.pyplot as plt
+
+def display_images(images, titles="Images", figsize=(15, 5)):
+    """
+    Display a list of images in a single row using Matplotlib.
+    
+    Parameters:
+    - images (list): List of images (NumPy arrays) to display.
+    - titles (str or list): Either a single string for overall title, or list of titles for each image.
+    - figsize (tuple): Size of the figure.
+    """
+    num_images = len(images)
+    fig, axes = plt.subplots(1, num_images, figsize=figsize)
+    if num_images == 1:
+        axes = [axes]  # Make iterable for single image
+
+    for i, (ax, image) in enumerate(zip(axes, images)):
+        image_rgb = image[:, :, ::-1]  # Convert BGR to RGB
+        ax.imshow(image_rgb)
+        ax.axis('off')
+        if isinstance(titles, list) and i < len(titles):
+            ax.set_title(titles[i], fontsize=12)
+
+    if isinstance(titles, str):
+        fig.suptitle(titles, fontsize=16)
+
+    plt.tight_layout()
+    plt.show()
+
+--------------------------------------------------------------------------------
+
+#Image sources
+image_source_1 = "../assets/person_1_multi_view.png"
+image_source_2 = "../assets/person_2_multi_view.png"
+
+# Detections
+detections_1 = person_det_model(image_source_1)
+detections_2 = person_det_model(image_source_2)
+
+display_images([detections_1.image_overlay, detections_2.image_overlay], titles=["Person_1 Detections", "Person_2 Detections"], figsize=(10, 5))
+
+--------------------------------------------------------------------------------
+
+# Cropping
+
+# Crops from the image_source_1
+x1, y1, x2, y2 = map(int, detections_1.results[0]["bbox"])  # Convert bbox coordinates to integers
+person1_crop1 = detections_1.image[y1:y2, x1:x2]  # Crop the person from the image
+
+x1, y1, x2, y2 = map(int, detections_1.results[1]["bbox"])  # Convert bbox coordinates to integers
+person1_crop2 = detections_1.image[y1:y2, x1:x2]  # Crop the person from the image
+
+# Crops from the image_source_2
+x1, y1, x2, y2 = map(int, detections_2.results[0]["bbox"])  # Convert bbox coordinates to integers
+person2_crop1 = detections_2.image[y1:y2, x1:x2]  # Crop the person from the image
+
+x1, y1, x2, y2 = map(int, detections_2.results[1]["bbox"])  # Convert bbox coordinates to integers
+person2_crop2 = detections_2.image[y1:y2, x1:x2]  # Crop the person from the image
+
+# Display person crops
+display_images([person1_crop1, person1_crop2, person2_crop1, person2_crop2], titles=["Person1 Crop1","Person1 Crop2","Person2 Crop1", "Person2 Crop2"], figsize=(10, 5))
+
+--------------------------------------------------------------------------------
+
+### Extracting embedding using a Re-Identification (ReID) model for each person crop
+
+--------------------------------------------------------------------------------
+
+import numpy as np
+#Extract the embeddings for the image_source_1 that has two crops
+embedding_person1_crop1 = np.asarray(person_reid_model(person1_crop1).results[0]["data"]).reshape(1, -1) # shape (1,512)
+embedding_person1_crop2 = np.asarray(person_reid_model(person1_crop2).results[0]["data"]).reshape(1, -1) # shape (1,512)
+
+#Extract the embeddings for the image_source_2 that detected two crops
+embedding_person2_crop1 = np.asarray(person_reid_model(person2_crop1).results[0]["data"]).reshape(1, -1) # shape (1,512)
+embedding_person2_crop2 = np.asarray(person_reid_model(person2_crop2).results[0]["data"]).reshape(1, -1) # shape (1,512)
+
+--------------------------------------------------------------------------------
+
+### Calculating cosine similarity between the embeddings
+
+--------------------------------------------------------------------------------
+
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Compute cosine similarity between crops of the same person on different camera views
+similarity_person1 = cosine_similarity(embedding_person1_crop1, embedding_person1_crop2)
+print("Cosine similarity between Person1 crops (two images of the person1 with different camera views):",similarity_person1)
+
+similarity_person2 = cosine_similarity(embedding_person2_crop1, embedding_person2_crop2)
+print("Cosine similarity between Person2 crops (two images of the person2 with different camera views):", similarity_person2, "\n")
+
+
+# Compute cosine similarity between crops of person1 and person2
+similarity_p1c1_p2c1 = cosine_similarity(embedding_person1_crop1, embedding_person2_crop1)
+print("Person 1 Crop 1 vs Person 2 Crop 1:", similarity_p1c1_p2c1)
+
+similarity_p1c1_p2c2 = cosine_similarity(embedding_person1_crop1, embedding_person2_crop2)
+print("Person 1 Crop 1 vs Person 2 Crop 2:", similarity_p1c1_p2c2)
+
+similarity_p1c2_p2c1 = cosine_similarity(embedding_person1_crop2, embedding_person2_crop1)
+print("Person 1 Crop 2 vs Person 2 Crop 1:", similarity_p1c2_p2c1)
+
+similarity_p1c2_p2c2 = cosine_similarity(embedding_person1_crop2, embedding_person2_crop2)
+print("Person 1 Crop 2 vs Person 2 Crop 2:", similarity_p1c2_p2c2)
+
+--------------------------------------------------------------------------------
+
+### Interpreting Cosine Similarity Results
+These results indicate that the Re-ID Osnet model effectively distinguishes between the same and different individuals:
+
+- **Intra-person similarities** (Person 1 & Person 2 across views) are consistently **high (~0.87–0.88)**.
+- **Inter-person similarities** (between different individuals) are **significantly lower (~0.44–0.55)**.
+
+In person re-identification, it's common to apply a **similarity threshold** (typically in the range of ~0.7–0.8) to determine whether two embeddings represent the same individual. <br>
+This threshold serves as a decision boundary: if the cosine similarity between two feature vectors (embeddings) exceeds the threshold, they are considered to belong to the same person; otherwise, they are treated as different individuals.
+
+The ideal threshold may vary — it's typically fine-tuned on a validation set to achieve the best trade-off between false positives and false negatives, and it often depends on the specific model architecture and characteristics of the dataset. The choice involves balancing False positives and False negatives.
+
+--------------------------------------------------------------------------------

text_files/016_custom_video_source.txt

@@ -0,0 +1,256 @@
+## Feed custom video source to `predict_batch` to DeGirum PySDK
+
+This guide is for developers who want to learn how to configure a custom video generator and feed it to DeGirum PySDK to use it for model predictions. In this guide, we will walk you through the steps on creating your own custom video generator and pass it to model object's `predict_batch` function to perform prediction over it.
+
+
+--------------------------------------------------------------------------------
+
+### Simple predictions on video stream 
+
+To begin with, lets take a look at how to run predictions on a simple video stream as is. For this, we will start with a simple frame generator function as below:
+
+--------------------------------------------------------------------------------
+
+# Define generator function to produce video frames
+def frame_source(stream):
+    while True:
+      ret, frame = stream.read()
+      if not ret:
+         break # end of file
+      yield frame
+
+--------------------------------------------------------------------------------
+
+We use this function to pass it to our `predict_batch` function as below:
+
+--------------------------------------------------------------------------------
+
+for result in model.predict_batch(frame_source(stream)):
+    # Print raw results for each frame
+    print(result)
+
+
+--------------------------------------------------------------------------------
+
+Putting it all together, lets run inference of a video source using simple video generator and `predict_batch` function:
+
+--------------------------------------------------------------------------------
+
+import degirum as dg
+import cv2
+
+# Declaring variables
+# Set your model, inference host address, model zoo, and token in these variables.
+your_model_name = "model-name"
+your_host_address = "@local" # Can be dg.CLOUD, host:port, or dg.LOCAL
+your_model_zoo = "degirum/hailo"
+your_token = "<token>"
+
+# Specify the video you will run inference on
+your_video = "path/video.mp4"
+
+# Loading a model
+model = dg.load_model(
+    model_name = your_model_name, 
+    inference_host_address = your_host_address, 
+    zoo_url = your_model_zoo, 
+    token = your_token 
+    # optional parameters, such as overlay_show_probabilities = True
+)
+
+# Open your video file
+stream = cv2.VideoCapture(your_video) 
+
+# Define generator function to produce video frames
+def frame_source(stream):
+    while True:
+      ret, frame = stream.read()
+      if not ret:
+         break # end of file
+      yield frame
+
+# Run predict_batch on stream of frames from video file
+for result in model.predict_batch(frame_source(stream)):
+    # Print raw results for each frame
+    print(result)
+
+# Release stream
+stream.release()
+
+--------------------------------------------------------------------------------
+
+#### Modify video generator to use webcam or Rpi stream
+
+In order to use webcam or an Rpi stream as video source, we will just modify our video source_path as below:
+
+--------------------------------------------------------------------------------
+
+##### Webcam input
+
+--------------------------------------------------------------------------------
+
+import degirum as dg
+import cv2
+
+# Declaring variables
+# Set your model, inference host address, model zoo, and token in these variables.
+your_model_name = "model-name"
+your_host_address = "@local" # Can be dg.CLOUD, host:port, or dg.LOCAL
+your_model_zoo = "degirum/hailo"
+your_token = "<token>"
+
+
+# Loading a model
+model = dg.load_model(
+    model_name = your_model_name, 
+    inference_host_address = your_host_address, 
+    zoo_url = your_model_zoo, 
+    token = your_token 
+    # optional parameters, such as overlay_show_probabilities = True
+)
+
+# Open your video file
+stream = cv2.VideoCapture(0) # Webcam source : 0 
+
+# Define generator function to produce video frames
+def frame_source(stream):
+    while True:
+      ret, frame = stream.read()
+      if not ret:
+         break # end of file
+      yield frame
+
+# Run predict_batch on stream of frames from video file
+for result in model.predict_batch(frame_source(stream)):
+    # Print raw results for each frame
+    print(result)
+
+# Release stream
+stream.release()
+
+--------------------------------------------------------------------------------
+
+#### Rpi Camera using PiCamera Module
+Similar to above example where we used OpenCV to capture frames from webcam, we can use `Picamera2` module to fetch frames from an Rpi Camera inside our frame generator function and pass that to `predict_batch`
+
+--------------------------------------------------------------------------------
+
+import cv2
+import degirum as dg
+import numpy as np
+from picamera2 import Picamera2
+
+your_model_name = "model-name"
+your_host_address = "@local" # Can be dg.CLOUD, host:port, or dg.LOCAL
+your_model_zoo = "degirum/hailo"
+your_token = "<token>"
+
+# Load the model
+model = dg.load_model(
+    model_name = your_model_name, 
+    inference_host_address = your_host_address, 
+    zoo_url = your_model_zoo, 
+    token = your_token 
+    # optional parameters, such as overlay_show_probabilities = True
+)
+
+# Define frame generator using Picamera2
+def picamera2_frame_generator():
+    picam2 = Picamera2()
+    picam2.configure(picam2.preview_configuration(main={"format": 'BGR888'}))
+    picam2.start()
+    try:
+        while True:
+            frame = picam2.capture_array()
+            yield frame
+    finally:
+        picam2.stop()
+
+# Run inference and display
+for result in model.predict_batch(picamera2_frame_generator(rotate=True)):
+    cv2.imshow("AI Inference PiCamera2", result.image_overlay)
+    if cv2.waitKey(1) & 0xFF == ord("q"):
+        break
+
+cv2.destroyAllWindows()
+
+
+--------------------------------------------------------------------------------
+
+#### Transform your video source before predictions
+
+Lets a take a look at how can you perform pre-processing or transformation on your input video source like rotation, resize, crop etc and perform model prediction over it. In this example, we will take camera input and rotate it 90' clockwise before passing it to `predict_batch` function.
+
+--------------------------------------------------------------------------------
+
+For this, we will modify our video generator as follows:
+
+--------------------------------------------------------------------------------
+
+def rotated_frame_generator(video_source):
+    stream = cv2.VideoCapture(video_source)
+    try:
+        while True:
+            ret, frame = stream.read()
+            if not ret:
+                break
+            rotated_frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE) # Rotate frame 90 degrees clockwise
+            yield rotated_frame
+    finally:
+        stream.release()
+
+--------------------------------------------------------------------------------
+
+Putting it all together, it looks like this:
+
+--------------------------------------------------------------------------------
+
+import degirum as dg
+import degirum_tools.video_support as vs
+import cv2
+import degirum_tools
+
+hw_location = "@local"
+model_zoo_url = "model_zoo_url"
+model_name = "your_model_name"
+video_source_path = 0 # Webcam source : 0
+degirum_cloud_token = "<token>" # Optional, only needed for cloud inference
+
+# Load the model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=hw_location,
+    zoo_url=model_zoo_url,
+    token=degirum_cloud_token,
+    overlay_color=(0, 255, 0)
+)
+
+# Define rotated frame generator
+def rotated_frame_generator(video_source):
+    stream = cv2.VideoCapture(video_source)
+    try:
+        while True:
+            ret, frame = stream.read()
+            if not ret:
+                break
+            rotated_frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)  # Rotate frame 90 degrees clockwise
+            yield rotated_frame
+    finally:
+        stream.release()
+
+# Run inference and display
+for result in model.predict_batch(rotated_frame_generator(video_source_path)):
+    cv2.imshow("AI Inference", result.image_overlay)
+    if cv2.waitKey(1) & 0xFF == ord("q"):
+        break
+
+cv2.destroyAllWindows()
+
+
+--------------------------------------------------------------------------------
+
+#### Conclusion
+
+In this guide, we have walked through the steps of setting up a custom video frame generator and pass it to model predictions using DeGirum PySDK. These steps allows you to modify and transform your video source feed and perform different operations such as rotation, crop etc and use the transformed video frames for model prediction. Such a process is useful especially when you want to modify your original source input for better accuracy on model predictions. 
+
+--------------------------------------------------------------------------------

text_files/object_detection_class_filtering.txt

@@ -0,0 +1,87 @@
+![Degirum banner](https://raw.githubusercontent.com/DeGirum/PySDKExamples/main/images/degirum_banner.png)
+## Object detection with class filtering on a video stream
+This notebook is a simple example of how to use DeGirum PySDK to do object detection AI inference 
+on an image file filtering only desired set of classes.
+
+This script works with the following inference options:
+
+1. Run inference on DeGirum Cloud Platform;
+2. Run inference on DeGirum AI Server deployed on a localhost or on some computer in your LAN or VPN;
+3. Run inference on DeGirum ORCA accelerator directly installed on your computer.
+
+To try different options, you need to specify the appropriate `hw_location` option. 
+
+When running this notebook locally, you need to specify your cloud API access token in the [env.ini](../../env.ini) file, located in the same directory as this notebook.
+
+When running this notebook in Google Colab, the cloud API access token should be stored in a user secret named `DEGIRUM_CLOUD_TOKEN`.
+
+
+--------------------------------------------------------------------------------
+
+# make sure degirum-tools package is installed
+!pip show degirum-tools || pip install degirum-tools
+
+--------------------------------------------------------------------------------
+
+#### Specify where you want to run your inferences, model zoo url, model name and video source
+
+--------------------------------------------------------------------------------
+
+# hw_location: where you want to run inference
+#     "@cloud" to use DeGirum cloud
+#     "@local" to run on local machine
+#     IP address for AI server inference
+# model_zoo_url: url/path for model zoo
+#     cloud_zoo_url: valid for @cloud, @local, and ai server inference options
+#     '': ai server serving models from local folder
+#     path to json file: single model zoo in case of @local inference
+# model_name: name of the model for running AI inference
+# image: image source for inference
+#     URL of image file
+#     path to image file (jpg, png, etc)
+# classes: set of class labels to accept
+hw_location = "@cloud"
+model_zoo_url = "degirum/public"
+model_name = "yolo_v5s_coco--512x512_quant_n2x_orca1_1"
+image = "https://raw.githubusercontent.com/DeGirum/PySDKExamples/main/images/bikes.jpg"
+classes = {"bicycle"}
+
+--------------------------------------------------------------------------------
+
+#### The rest of the cells below should run without any modifications
+
+--------------------------------------------------------------------------------
+
+import degirum as dg, degirum_tools
+
+# connect to AI inference engine and load object detection AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=hw_location,
+    zoo_url=model_zoo_url,
+    token=degirum_tools.get_token(),    
+)
+
+# AI prediction: show only desired classes
+with degirum_tools.Display("All classes (press 'q' to exit)") as display:
+    inference_result = model(image)
+    display.show_image(inference_result)
+
+--------------------------------------------------------------------------------
+
+# connect to AI inference engine and load object detection AI model
+# setting `output_class_set` to desired classes
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=hw_location,
+    zoo_url=model_zoo_url,
+    token=degirum_tools.get_token(),  
+    output_class_set=classes  
+)
+
+# AI prediction: show only desired classes
+with degirum_tools.Display("Only bikes (press 'q' to exit)") as display:
+    inference_result = model(image)
+    display.show_image(inference_result)
+
+--------------------------------------------------------------------------------

text_files/object_detection_image.txt

@@ -0,0 +1,71 @@
+![Degirum banner](https://raw.githubusercontent.com/DeGirum/PySDKExamples/main/images/degirum_banner.png)
+## Simple example script illustrating object detection
+This notebook is one of the simplest examples of how to use the DeGirum PySDK to do AI inference on a graphical file using an object detection model.
+
+This script works with the following inference options:
+
+1. Run inference on the DeGirum Cloud Platform;
+2. Run inference on a DeGirum AI Server deployed on the local host or on some computer in your LAN or VPN;
+3. Run inference on a DeGirum ORCA accelerator directly installed on your computer.
+
+To try different options, you need to specify the appropriate `hw_location` option. 
+
+When running this notebook locally, you need to specify your cloud API access token in the [env.ini](../../env.ini) file, located in the same directory as this notebook.
+
+When running this notebook in Google Colab, the cloud API access token should be stored in a user secret named `DEGIRUM_CLOUD_TOKEN`.
+
+--------------------------------------------------------------------------------
+
+# make sure degirum-tools package is installed
+!pip show degirum-tools || pip install degirum-tools
+
+--------------------------------------------------------------------------------
+
+#### Specify where you want to run your inferences, model zoo url, model name and image source
+
+--------------------------------------------------------------------------------
+
+# hw_location: where you want to run inference
+#     "@cloud" to use DeGirum cloud
+#     "@local" to run on local machine
+#     IP address for AI server inference
+# model_zoo_url: url/path for model zoo
+#     cloud_zoo_url: valid for @cloud, @local, and ai server inference options
+#     '': ai server serving models from local folder
+#     path to json file: single model zoo in case of @local inference
+# model_name: name of the model for running AI inference
+# img: image source for inference
+#     path to image file
+#     URL of image
+#     PIL image object
+#     numpy array
+hw_location = "@cloud"
+model_zoo_url = "degirum/public"
+model_name = "mobilenet_v2_ssd_coco--300x300_quant_n2x_orca1_1"
+image_source = "https://raw.githubusercontent.com/DeGirum/PySDKExamples/main/images/TwoCats.jpg"
+
+--------------------------------------------------------------------------------
+
+#### The rest of the cells below should run without any modifications
+
+--------------------------------------------------------------------------------
+
+import degirum as dg, degirum_tools
+
+# load object detection AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=hw_location,
+    zoo_url=model_zoo_url,
+    token=degirum_tools.get_token(),
+)
+
+# perform AI model inference on given image source
+inference_result = model(image_source)
+
+# show results of inference
+print(inference_result)  # numeric results
+with degirum_tools.Display("AI Camera") as display:
+    display.show_image(inference_result)
+
+--------------------------------------------------------------------------------

text_files/object_detection_video_stream.txt

@@ -0,0 +1,75 @@
+![Degirum banner](https://raw.githubusercontent.com/DeGirum/PySDKExamples/main/images/degirum_banner.png)
+## AI Inference on a video stream
+This notebook is a simple example of how to use DeGirum PySDK to do AI inference on a video stream.
+
+This script works with the following inference options:
+
+1. Run inference on DeGirum Cloud Platform;
+2. Run inference on DeGirum AI Server deployed on a localhost or on some computer in your LAN or VPN;
+3. Run inference on DeGirum ORCA accelerator directly installed on your computer.
+
+To try different options, you need to specify the appropriate `hw_location` option. 
+
+When running this notebook locally, you need to specify your cloud API access token in the [env.ini](../../env.ini) file, located in the same directory as this notebook.
+
+When running this notebook in Google Colab, the cloud API access token should be stored in a user secret named `DEGIRUM_CLOUD_TOKEN`.
+
+You can change `video_source` to index of a local webcamera, or URL of an RTSP stream, or URL of a YouTube video, or path to another video file.
+
+
+--------------------------------------------------------------------------------
+
+# make sure degirum-tools package is installed
+!pip show degirum-tools || pip install degirum-tools
+
+--------------------------------------------------------------------------------
+
+#### Specify where you want to run your inferences, model zoo url, model name and video source
+
+--------------------------------------------------------------------------------
+
+# hw_location: where you want to run inference
+#     "@cloud" to use DeGirum cloud
+#     "@local" to run on local machine
+#     IP address for AI server inference
+# model_zoo_url: url/path for model zoo
+#     cloud_zoo_url: valid for @cloud, @local, and ai server inference options
+#     '': ai server serving models from local folder
+#     path to json file: single model zoo in case of @local inference
+# model_name: name of the model for running AI inference
+# video_source: video source for inference
+#     camera index for local camera
+#     URL of RTSP stream
+#     URL of YouTube Video
+#     path to video file (mp4 etc)
+hw_location = "@cloud"
+model_zoo_url = "degirum/public"
+model_name = "yolo_v5s_coco--512x512_quant_n2x_orca1_1"
+video_source = "https://raw.githubusercontent.com/DeGirum/PySDKExamples/main/images/example_video.mp4"
+
+--------------------------------------------------------------------------------
+
+#### The rest of the cells below should run without any modifications
+
+--------------------------------------------------------------------------------
+
+import degirum as dg, degirum_tools
+
+# load object detection AI model
+model = dg.load_model(
+    model_name=model_name,
+    inference_host_address=hw_location,
+    zoo_url=model_zoo_url,
+    token=degirum_tools.get_token(),
+)
+
+# run AI inference on video stream
+inference_results = degirum_tools.predict_stream(model, video_source)
+
+# display inference results
+# Press 'x' or 'q' to stop
+with degirum_tools.Display("AI Camera") as display:
+    for inference_result in inference_results:
+        display.show(inference_result)
+
+--------------------------------------------------------------------------------