{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": [],
"gpuType": "T4"
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
},
"accelerator": "GPU"
},
"cells": [
{
"cell_type": "markdown",
"source": [
"#**Image and Video segmentation using SAM and YOLO-NAS**"
],
"metadata": {
"id": "W5RYMhfCGFoE"
}
},
{
"cell_type": "markdown",
"source": [
"Steps:\n",
" 1. Install All the Required Packages\n",
" 2. Import All the Required Libraries\n",
" 3. Download Some Demo Videos From Drive into the Google Colab Notebook\n",
" 4. Load the Input Video and calculate the Frame Width and Frame Height\n",
" 5. Download the Pre-Trained YOLO-NAS Model Weights\n",
" 6. Object Detection with YOLO-NAS\n",
" 7. Display the Output Demo Video\n",
" 8. Download the Checkpoint for the Segment Anything Model (SAM)\n",
" 9. Initialize SAM Automatic Mask Generator parameters and Draw Segmented Mask\n",
" 10. Load the Segment Anything Model Checkpoint and return the Segment Anything Model\n",
" 11. Video Segmentation using YOLO-NAS and SAM\n",
" 12. Display the Output Video\n",
" 13. Image Segmentation with YOLO-NAS and SAM\n"
],
"metadata": {
"id": "vOjaoQUYGOFD"
}
},
{
"cell_type": "markdown",
"source": [
"#**🚨 Before Running the Script Please Make Sure you have selected the Run Time as GPU**"
],
"metadata": {
"id": "ewjNDDbKIopV"
}
},
{
"cell_type": "markdown",
"source": [
"#**Step 01: Install All the Required Packages**"
],
"metadata": {
"id": "fkOeNtJQrEcq"
}
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"id": "bqfafYo-rAe_"
},
"outputs": [],
"source": [
"!pip install -q super_gradients==3.1.3\n",
"!pip install -q segment_anything\n",
"!pip install -q supervision"
]
},
{
"cell_type": "markdown",
"source": [
"#**🚨 Restart the Run Time**"
],
"metadata": {
"id": "Agak5zKnBKcr"
}
},
{
"cell_type": "markdown",
"source": [
"#**Step 02:Import All the Required Libraries**"
],
"metadata": {
"id": "QvNnMA8wraNK"
}
},
{
"cell_type": "code",
"source": [
"import cv2\n",
"import torch\n",
"import math\n",
"import numpy as np\n",
"from numpy import random\n",
"import supervision as sv\n",
"import matplotlib.pyplot as plt\n",
"from google.colab.patches import cv2_imshow\n",
"from super_gradients.training import models\n",
"from segment_anything import sam_model_registry, SamAutomaticMaskGenerator, SamPredictor"
],
"metadata": {
"id": "CpHmQsxArcjn"
},
"execution_count": 66,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"#**Step 03: Download Some Demo Videos From Drive into the Google Colab Notebook**"
],
"metadata": {
"id": "93Vdy6sisO_f"
}
},
{
"cell_type": "code",
"source": [
"!gdown \"https://drive.google.com/uc?id=1W37PKVxDNl1wngrvdMgK8RStxPWwMYCM&confirm=t\"\n",
"!gdown \"https://drive.google.com/uc?id=1rQq9Uq8f-KjoWX0Zn_-_9KOLcLX4hurX&confirm=t\"\n",
"!gdown \"https://drive.google.com/uc?id=1_yvsJOqtdi8FelROqzmRTjl9-S1bEt6g&confirm=t\"\n",
"!gdown \"https://drive.google.com/uc?id=1340mqENg7yzDKtD28xVpHkrYBmbYxiS_&confirm=t\"\n",
"!gdown \"https://drive.google.com/uc?id=1oHW1XFMi9S3alNowylQKS3Y8FeF27TFo&confirm=t\""
],
"metadata": {
"id": "dPqNkLL_vvv-",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "a3bfe175-5123-4af5-f4d5-50c14fd12649"
},
"execution_count": 55,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Downloading...\n",
"From: https://drive.google.com/uc?id=1W37PKVxDNl1wngrvdMgK8RStxPWwMYCM&confirm=t\n",
"To: /content/carvideo.mp4\n",
"100% 951k/951k [00:00<00:00, 76.1MB/s]\n",
"Downloading...\n",
"From: https://drive.google.com/uc?id=1rQq9Uq8f-KjoWX0Zn_-_9KOLcLX4hurX&confirm=t\n",
"To: /content/Football_Video.mp4\n",
"100% 5.11M/5.11M [00:00<00:00, 188MB/s]\n",
"Downloading...\n",
"From: https://drive.google.com/uc?id=1_yvsJOqtdi8FelROqzmRTjl9-S1bEt6g&confirm=t\n",
"To: /content/DrpoedShot.mp4\n",
"100% 6.86M/6.86M [00:00<00:00, 92.4MB/s]\n",
"Downloading...\n",
"From: https://drive.google.com/uc?id=1340mqENg7yzDKtD28xVpHkrYBmbYxiS_&confirm=t\n",
"To: /content/video212.mp4\n",
"100% 1.28M/1.28M [00:00<00:00, 164MB/s]\n",
"Downloading...\n",
"From: https://drive.google.com/uc?id=1oHW1XFMi9S3alNowylQKS3Y8FeF27TFo&confirm=t\n",
"To: /content/Basketball_video.mp4\n",
"100% 7.85M/7.85M [00:00<00:00, 77.0MB/s]\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"#**Step 04: Load the Input Video and calculate the Frame Width and Frame Height**"
],
"metadata": {
"id": "tx45-B6psdx9"
}
},
{
"cell_type": "code",
"source": [
"cap=cv2.VideoCapture(\"/content/Football_Video.mp4\")\n",
"frame_width=int(cap.get(3))\n",
"frame_height=int(cap.get(4))"
],
"metadata": {
"id": "cW9Urk8zre52"
},
"execution_count": 28,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"#**Step 05: Download the Pre-Trained YOLO-NAS Model Weights**"
],
"metadata": {
"id": "d1IJJCnDugf9"
}
},
{
"cell_type": "code",
"source": [
"device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
"model = models.get('yolo_nas_s', pretrained_weights=\"coco\").to(device)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "RLGkn9narfA1",
"outputId": "15441083-1b96-4e1b-819a-93803361d976"
},
"execution_count": 56,
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 16:47:49] INFO - checkpoint_utils.py - License Notification: YOLO-NAS pre-trained weights are subjected to the specific license terms and conditions detailed in \n",
"https://github.com/Deci-AI/super-gradients/blob/master/LICENSE.YOLONAS.md\n",
"By downloading the pre-trained weight files you agree to comply with these terms.\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"#**Step 06: Object Detection with YOLO-NAS**"
],
"metadata": {
"id": "rSDhr4l4NX6b"
}
},
{
"cell_type": "code",
"source": [
"names = [\"person\", \"bicycle\", \"car\", \"motorbike\", \"aeroplane\", \"bus\", \"train\", \"truck\", \"boat\", \"traffic light\", \"fire hydrant\", \"stop sign\", \"parking meter\", \"bench\", \"bird\", \"cat\", \"dog\", \"horse\", \"sheep\", \"cow\", \"elephant\", \"bear\", \"zebra\", \"giraffe\", \"backpack\", \"umbrella\",\"handbag\", \"tie\", \"suitcase\", \"frisbee\", \"skis\", \"snowboard\", \"sports ball\", \"kite\", \"baseball bat\",\"baseball glove\", \"skateboard\", \"surfboard\", \"tennis racket\", \"bottle\", \"wine glass\", \"cup\",\"fork\", \"knife\", \"spoon\", \"bowl\", \"banana\", \"apple\", \"sandwich\", \"orange\", \"broccoli\",\"carrot\", \"hot dog\", \"pizza\", \"donut\", \"cake\", \"chair\", \"sofa\", \"pottedplant\", \"bed\",\"diningtable\", \"toilet\", \"tvmonitor\", \"laptop\", \"mouse\", \"remote\", \"keyboard\", \"cell phone\",\"microwave\", \"oven\", \"toaster\", \"sink\", \"refrigerator\", \"book\", \"clock\", \"vase\", \"scissors\",\"teddy bear\", \"hair drier\", \"toothbrush\" ]\n",
"out = cv2.VideoWriter('Output1.avi', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 10, (frame_width, frame_height))\n",
"count = 0\n",
"while True:\n",
" ret, frame = cap.read()\n",
" count += 1\n",
" if ret:\n",
" result = list(model.predict(frame, conf=0.35))[0]\n",
" bbox_xyxys = result.prediction.bboxes_xyxy.tolist()\n",
" confidences = result.prediction.confidence\n",
" labels = result.prediction.labels.tolist()\n",
" for (bbox_xyxy, confidence, cls) in zip(bbox_xyxys, confidences, labels):\n",
" bbox = np.array(bbox_xyxy)\n",
" x1, y1, x2, y2 = bbox[0], bbox[1], bbox[2], bbox[3]\n",
" x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)\n",
" classname = int(cls)\n",
" class_name = names[classname]\n",
" conf = math.ceil((confidence*100))/100\n",
" label = f'{class_name}{conf}'\n",
" print(\"Frame N\", count, \"\", x1, y1,x2, y2)\n",
" t_size = cv2.getTextSize(label, 0, fontScale = 1, thickness=2)[0]\n",
" c2 = x1 + t_size[0], y1 - t_size[1] -3\n",
" cv2.rectangle(frame, (x1, y1), c2, [255, 144, 30], -1, cv2.LINE_AA)\n",
" cv2.putText(frame, label, (x1, y1-2), 0, 1, [255, 255, 255], thickness=1, lineType = cv2.LINE_AA)\n",
" cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 255), 3)\n",
" resize_frame = cv2.resize(frame, (0, 0), fx=0.5, fy=0.5, interpolation=cv2.INTER_AREA)\n",
" out.write(frame)\n",
" else:\n",
" break\n",
"\n",
"out.release()\n",
"cap.release()"
],
"metadata": {
"id": "Rh-JCFZ4rfGU",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "ae432a75-622a-47d6-a9d0-c343adc16a8b"
},
"execution_count": 30,
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:43] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n",
"[2023-08-01 14:49:43] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 1 666 449 687 516\n",
"Frame N 1 731 418 759 465\n",
"Frame N 1 689 291 708 340\n",
"Frame N 1 848 267 870 315\n",
"Frame N 1 790 285 812 331\n",
"Frame N 1 525 295 555 344\n",
"Frame N 1 908 298 933 339\n",
"Frame N 1 433 360 467 412\n",
"Frame N 1 608 334 646 388\n",
"Frame N 1 680 378 704 432\n",
"Frame N 1 500 321 520 373\n",
"Frame N 1 905 298 937 347\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:44] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 2 434 359 476 412\n",
"Frame N 2 681 378 703 424\n",
"Frame N 2 663 448 684 502\n",
"Frame N 2 694 290 711 334\n",
"Frame N 2 1014 219 1033 263\n",
"Frame N 2 914 299 931 337\n",
"Frame N 2 853 268 874 312\n",
"Frame N 2 792 286 814 332\n",
"Frame N 2 615 335 632 387\n",
"Frame N 2 530 293 548 340\n",
"Frame N 2 499 320 525 372\n",
"Frame N 2 500 320 522 361\n",
"Frame N 2 731 418 755 460\n",
"Frame N 2 613 339 637 391\n",
"Frame N 2 528 293 557 342\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:44] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 3 657 448 702 517\n",
"Frame N 3 856 265 887 313\n",
"Frame N 3 433 360 461 411\n",
"Frame N 3 916 300 935 344\n",
"Frame N 3 730 416 774 465\n",
"Frame N 3 680 378 703 426\n",
"Frame N 3 499 319 532 372\n",
"Frame N 3 618 336 636 381\n",
"Frame N 3 794 284 824 331\n",
"Frame N 3 1020 221 1044 264\n",
"Frame N 3 696 290 717 340\n",
"Frame N 3 433 359 477 411\n",
"Frame N 3 532 293 552 337\n",
"Frame N 3 532 293 560 340\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:44] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 4 651 447 705 515\n",
"Frame N 4 860 267 893 311\n",
"Frame N 4 916 299 944 346\n",
"Frame N 4 433 359 467 413\n",
"Frame N 4 796 286 831 331\n",
"Frame N 4 698 290 721 337\n",
"Frame N 4 499 319 532 370\n",
"Frame N 4 618 334 638 381\n",
"Frame N 4 680 378 702 428\n",
"Frame N 4 729 416 775 462\n",
"Frame N 4 535 294 556 336\n",
"Frame N 4 1028 225 1052 266\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:44] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 5 646 448 701 516\n",
"Frame N 5 916 300 952 347\n",
"Frame N 5 431 359 470 410\n",
"Frame N 5 702 290 734 337\n",
"Frame N 5 682 377 710 429\n",
"Frame N 5 865 266 898 312\n",
"Frame N 5 503 319 524 365\n",
"Frame N 5 798 288 836 333\n",
"Frame N 5 619 333 637 378\n",
"Frame N 5 1035 225 1055 267\n",
"Frame N 5 542 294 559 334\n",
"Frame N 5 730 418 772 462\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:45] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 6 646 448 701 516\n",
"Frame N 6 916 300 952 347\n",
"Frame N 6 430 359 470 410\n",
"Frame N 6 702 290 734 337\n",
"Frame N 6 682 377 714 430\n",
"Frame N 6 865 266 898 312\n",
"Frame N 6 504 319 524 364\n",
"Frame N 6 798 288 837 333\n",
"Frame N 6 730 418 772 462\n",
"Frame N 6 619 333 637 378\n",
"Frame N 6 1034 225 1055 267\n",
"Frame N 6 542 294 559 335\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:45] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 7 731 418 763 465\n",
"Frame N 7 922 301 954 343\n",
"Frame N 7 434 360 478 412\n",
"Frame N 7 686 379 714 435\n",
"Frame N 7 653 450 691 513\n",
"Frame N 7 872 268 888 313\n",
"Frame N 7 621 333 640 379\n",
"Frame N 7 506 320 524 361\n",
"Frame N 7 546 295 566 341\n",
"Frame N 7 707 288 723 333\n",
"Frame N 7 1041 226 1062 268\n",
"Frame N 7 802 288 824 334\n",
"Frame N 7 915 300 959 345\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:45] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 8 440 359 484 413\n",
"Frame N 8 730 415 758 465\n",
"Frame N 8 653 452 677 516\n",
"Frame N 8 711 288 733 337\n",
"Frame N 8 687 379 709 432\n",
"Frame N 8 878 268 898 315\n",
"Frame N 8 1046 225 1075 266\n",
"Frame N 8 931 301 949 342\n",
"Frame N 8 928 301 955 343\n",
"Frame N 8 551 296 573 343\n",
"Frame N 8 619 333 642 381\n",
"Frame N 8 511 321 527 360\n",
"Frame N 8 809 290 831 335\n",
"Frame N 8 614 333 644 385\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:45] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 9 647 451 683 519\n",
"Frame N 9 813 292 834 339\n",
"Frame N 9 443 360 484 412\n",
"Frame N 9 716 288 737 336\n",
"Frame N 9 936 303 953 346\n",
"Frame N 9 686 379 714 432\n",
"Frame N 9 1053 226 1085 266\n",
"Frame N 9 731 417 756 463\n",
"Frame N 9 731 416 767 464\n",
"Frame N 9 883 269 899 312\n",
"Frame N 9 555 295 583 344\n",
"Frame N 9 626 333 646 382\n",
"Frame N 9 513 322 533 376\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:46] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 10 646 450 693 518\n",
"Frame N 10 943 304 959 346\n",
"Frame N 10 445 360 478 412\n",
"Frame N 10 886 269 913 314\n",
"Frame N 10 719 286 745 333\n",
"Frame N 10 816 293 845 339\n",
"Frame N 10 629 333 651 388\n",
"Frame N 10 559 296 593 344\n",
"Frame N 10 687 379 715 434\n",
"Frame N 10 730 419 756 464\n",
"Frame N 10 730 418 765 464\n",
"Frame N 10 1060 227 1092 268\n",
"Frame N 10 1060 227 1083 267\n",
"Frame N 10 446 360 493 411\n",
"Frame N 10 513 322 543 376\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:46] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 11 636 452 696 519\n",
"Frame N 11 892 269 924 315\n",
"Frame N 11 449 360 493 413\n",
"Frame N 11 724 286 752 333\n",
"Frame N 11 946 304 962 347\n",
"Frame N 11 562 296 600 343\n",
"Frame N 11 820 293 855 337\n",
"Frame N 11 689 379 710 435\n",
"Frame N 11 632 334 651 389\n",
"Frame N 11 732 418 753 460\n",
"Frame N 11 514 322 549 372\n",
"Frame N 11 1068 228 1090 267\n",
"Frame N 11 1067 229 1103 266\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:46] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 12 636 452 696 519\n",
"Frame N 12 892 269 924 315\n",
"Frame N 12 449 360 494 413\n",
"Frame N 12 562 296 600 343\n",
"Frame N 12 946 304 962 347\n",
"Frame N 12 724 286 753 333\n",
"Frame N 12 820 293 855 337\n",
"Frame N 12 632 334 651 389\n",
"Frame N 12 689 379 710 435\n",
"Frame N 12 732 418 753 460\n",
"Frame N 12 514 321 548 372\n",
"Frame N 12 1068 227 1090 267\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:47] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 13 635 450 690 519\n",
"Frame N 13 896 271 932 316\n",
"Frame N 13 947 306 976 352\n",
"Frame N 13 822 294 861 337\n",
"Frame N 13 633 333 657 386\n",
"Frame N 13 635 450 673 518\n",
"Frame N 13 731 418 774 469\n",
"Frame N 13 455 362 492 413\n",
"Frame N 13 730 286 754 332\n",
"Frame N 13 1076 230 1104 272\n",
"Frame N 13 518 321 537 371\n",
"Frame N 13 692 380 714 437\n",
"Frame N 13 568 294 589 339\n",
"Frame N 13 566 294 602 341\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:47] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 14 640 451 672 520\n",
"Frame N 14 949 307 984 352\n",
"Frame N 14 734 419 756 471\n",
"Frame N 14 694 382 717 438\n",
"Frame N 14 635 333 659 383\n",
"Frame N 14 903 272 934 317\n",
"Frame N 14 735 286 758 331\n",
"Frame N 14 466 362 491 413\n",
"Frame N 14 575 295 592 343\n",
"Frame N 14 826 293 856 338\n",
"Frame N 14 572 295 597 344\n",
"Frame N 14 734 419 767 472\n",
"Frame N 14 1085 232 1105 275\n",
"Frame N 14 522 321 539 362\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:47] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 15 470 360 500 413\n",
"Frame N 15 1093 233 1112 276\n",
"Frame N 15 645 452 670 520\n",
"Frame N 15 692 381 718 434\n",
"Frame N 15 912 272 935 316\n",
"Frame N 15 740 285 759 330\n",
"Frame N 15 737 420 759 468\n",
"Frame N 15 952 310 985 353\n",
"Frame N 15 580 297 597 343\n",
"Frame N 15 524 324 552 374\n",
"Frame N 15 632 332 663 383\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:47] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 16 472 359 507 412\n",
"Frame N 16 733 419 771 470\n",
"Frame N 16 637 333 674 384\n",
"Frame N 16 643 452 666 505\n",
"Frame N 16 917 272 935 317\n",
"Frame N 16 743 285 769 330\n",
"Frame N 16 531 323 549 377\n",
"Frame N 16 1099 233 1123 277\n",
"Frame N 16 838 298 861 345\n",
"Frame N 16 585 296 605 344\n",
"Frame N 16 690 380 727 439\n",
"Frame N 16 694 381 720 436\n",
"Frame N 16 963 312 980 346\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:47] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 17 639 452 681 520\n",
"Frame N 17 475 360 513 408\n",
"Frame N 17 729 420 777 470\n",
"Frame N 17 640 333 672 389\n",
"Frame N 17 747 284 775 331\n",
"Frame N 17 1105 235 1134 276\n",
"Frame N 17 693 381 720 437\n",
"Frame N 17 840 297 867 345\n",
"Frame N 17 968 313 989 355\n",
"Frame N 17 921 272 945 320\n",
"Frame N 17 589 296 613 342\n",
"Frame N 17 531 324 554 374\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:48] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 18 639 452 681 520\n",
"Frame N 18 475 360 513 408\n",
"Frame N 18 730 420 777 470\n",
"Frame N 18 640 333 672 389\n",
"Frame N 18 1105 235 1134 276\n",
"Frame N 18 747 284 775 331\n",
"Frame N 18 841 297 867 345\n",
"Frame N 18 695 381 720 436\n",
"Frame N 18 968 313 989 355\n",
"Frame N 18 589 296 613 341\n",
"Frame N 18 921 272 945 320\n",
"Frame N 18 532 324 554 374\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:48] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 19 634 452 688 519\n",
"Frame N 19 926 273 956 320\n",
"Frame N 19 973 316 991 361\n",
"Frame N 19 842 297 877 344\n",
"Frame N 19 732 421 759 468\n",
"Frame N 19 476 360 513 409\n",
"Frame N 19 652 334 669 387\n",
"Frame N 19 1110 236 1144 281\n",
"Frame N 19 476 359 502 409\n",
"Frame N 19 752 284 769 329\n",
"Frame N 19 699 381 719 435\n",
"Frame N 19 532 327 564 375\n",
"Frame N 19 731 421 771 467\n",
"Frame N 19 694 380 718 438\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:48] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 20 628 453 686 518\n",
"Frame N 20 975 317 996 359\n",
"Frame N 20 931 272 963 319\n",
"Frame N 20 654 333 672 385\n",
"Frame N 20 1117 237 1151 282\n",
"Frame N 20 736 422 757 473\n",
"Frame N 20 846 300 877 345\n",
"Frame N 20 703 381 721 439\n",
"Frame N 20 481 359 509 411\n",
"Frame N 20 756 284 777 331\n",
"Frame N 20 845 300 868 346\n",
"Frame N 20 595 296 625 346\n",
"Frame N 20 534 324 561 372\n",
"Frame N 20 735 422 772 473\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:48] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 21 975 317 1009 362\n",
"Frame N 21 634 454 670 520\n",
"Frame N 21 738 422 763 474\n",
"Frame N 21 1126 240 1157 283\n",
"Frame N 21 935 273 969 321\n",
"Frame N 21 846 301 880 347\n",
"Frame N 21 847 302 870 347\n",
"Frame N 21 657 333 674 380\n",
"Frame N 21 762 284 786 331\n",
"Frame N 21 488 360 514 411\n",
"Frame N 21 703 381 726 439\n",
"Frame N 21 540 323 559 356\n",
"Frame N 21 597 296 621 345\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:49] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 22 636 455 668 523\n",
"Frame N 22 657 332 686 384\n",
"Frame N 22 981 320 1014 360\n",
"Frame N 22 492 360 519 412\n",
"Frame N 22 853 300 877 349\n",
"Frame N 22 704 384 726 435\n",
"Frame N 22 1135 241 1158 287\n",
"Frame N 22 735 422 763 470\n",
"Frame N 22 944 275 961 323\n",
"Frame N 22 766 284 786 331\n",
"Frame N 22 942 275 970 324\n",
"Frame N 22 601 298 636 345\n",
"Frame N 22 604 298 624 345\n",
"Frame N 22 539 323 562 371\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:49] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 23 633 456 665 526\n",
"Frame N 23 495 360 528 411\n",
"Frame N 23 657 331 689 382\n",
"Frame N 23 860 304 881 352\n",
"Frame N 23 705 384 727 433\n",
"Frame N 23 982 322 1009 361\n",
"Frame N 23 769 285 790 327\n",
"Frame N 23 735 422 774 473\n",
"Frame N 23 1142 242 1161 284\n",
"Frame N 23 610 300 633 347\n",
"Frame N 23 545 325 565 378\n",
"Frame N 23 769 283 798 330\n",
"Frame N 23 609 299 640 348\n",
"Frame N 23 950 276 968 323\n",
"Frame N 23 696 384 725 437\n",
"Frame N 23 978 322 1024 363\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:49] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 24 633 456 665 526\n",
"Frame N 24 496 359 528 411\n",
"Frame N 24 657 331 689 382\n",
"Frame N 24 860 304 881 352\n",
"Frame N 24 705 384 727 432\n",
"Frame N 24 982 322 1010 361\n",
"Frame N 24 769 285 790 327\n",
"Frame N 24 735 422 774 473\n",
"Frame N 24 1142 242 1161 284\n",
"Frame N 24 610 300 633 347\n",
"Frame N 24 768 283 798 330\n",
"Frame N 24 950 276 969 323\n",
"Frame N 24 545 325 565 378\n",
"Frame N 24 978 322 1024 363\n",
"Frame N 24 695 384 724 437\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:49] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 25 629 454 672 524\n",
"Frame N 25 497 359 533 411\n",
"Frame N 25 704 384 727 436\n",
"Frame N 25 862 307 887 354\n",
"Frame N 25 551 326 569 378\n",
"Frame N 25 733 423 776 472\n",
"Frame N 25 667 332 695 382\n",
"Frame N 25 955 278 972 322\n",
"Frame N 25 1148 243 1173 285\n",
"Frame N 25 990 322 1014 363\n",
"Frame N 25 772 284 789 325\n",
"Frame N 25 987 322 1023 365\n",
"Frame N 25 615 301 637 349\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:50] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 26 623 455 677 520\n",
"Frame N 26 494 360 538 410\n",
"Frame N 26 864 307 897 354\n",
"Frame N 26 998 324 1019 364\n",
"Frame N 26 708 383 727 440\n",
"Frame N 26 958 278 984 323\n",
"Frame N 26 670 332 689 385\n",
"Frame N 26 553 325 576 380\n",
"Frame N 26 1154 245 1184 285\n",
"Frame N 26 731 423 761 476\n",
"Frame N 26 621 301 645 351\n",
"Frame N 26 731 424 779 475\n",
"Frame N 26 777 285 801 327\n",
"Frame N 26 668 332 695 387\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:50] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 27 617 454 677 520\n",
"Frame N 27 961 279 993 325\n",
"Frame N 27 1159 246 1197 288\n",
"Frame N 27 733 424 774 477\n",
"Frame N 27 866 307 904 352\n",
"Frame N 27 1003 326 1020 369\n",
"Frame N 27 709 384 728 441\n",
"Frame N 27 782 283 803 328\n",
"Frame N 27 504 361 533 410\n",
"Frame N 27 674 333 690 381\n",
"Frame N 27 623 301 644 344\n",
"Frame N 27 502 362 542 408\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:50] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 28 619 454 667 523\n",
"Frame N 28 964 279 1000 327\n",
"Frame N 28 1003 330 1024 371\n",
"Frame N 28 626 301 661 348\n",
"Frame N 28 677 332 694 374\n",
"Frame N 28 730 425 764 480\n",
"Frame N 28 1165 246 1200 290\n",
"Frame N 28 867 309 905 352\n",
"Frame N 28 711 383 730 432\n",
"Frame N 28 785 283 804 328\n",
"Frame N 28 506 363 539 413\n",
"Frame N 28 554 324 591 376\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:51] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 29 1003 329 1034 375\n",
"Frame N 29 969 281 1004 329\n",
"Frame N 29 623 455 657 524\n",
"Frame N 29 787 284 811 328\n",
"Frame N 29 708 386 737 434\n",
"Frame N 29 508 363 539 413\n",
"Frame N 29 871 306 904 356\n",
"Frame N 29 676 332 699 380\n",
"Frame N 29 731 425 759 473\n",
"Frame N 29 1173 249 1205 292\n",
"Frame N 29 627 300 667 348\n",
"Frame N 29 558 324 577 373\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:51] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 30 1003 329 1034 375\n",
"Frame N 30 969 281 1005 329\n",
"Frame N 30 623 455 657 524\n",
"Frame N 30 787 284 811 328\n",
"Frame N 30 708 386 737 434\n",
"Frame N 30 508 363 539 413\n",
"Frame N 30 731 425 759 476\n",
"Frame N 30 871 306 904 356\n",
"Frame N 30 676 332 699 380\n",
"Frame N 30 627 300 667 348\n",
"Frame N 30 1173 249 1205 292\n",
"Frame N 30 558 324 577 373\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:51] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 31 623 456 649 523\n",
"Frame N 31 788 283 817 328\n",
"Frame N 31 1004 332 1043 377\n",
"Frame N 31 876 308 896 358\n",
"Frame N 31 515 363 540 414\n",
"Frame N 31 708 386 736 435\n",
"Frame N 31 729 424 771 478\n",
"Frame N 31 977 282 1008 330\n",
"Frame N 31 632 301 652 347\n",
"Frame N 31 676 332 701 383\n",
"Frame N 31 1181 250 1205 296\n",
"Frame N 31 -1 270 18 321\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:51] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 32 619 454 658 525\n",
"Frame N 32 518 361 548 412\n",
"Frame N 32 634 301 668 351\n",
"Frame N 32 3 269 30 323\n",
"Frame N 32 703 385 736 436\n",
"Frame N 32 983 284 1005 328\n",
"Frame N 32 878 309 901 359\n",
"Frame N 32 788 283 823 326\n",
"Frame N 32 679 331 703 382\n",
"Frame N 32 1007 332 1037 379\n",
"Frame N 32 727 425 776 477\n",
"Frame N 32 675 331 708 386\n",
"Frame N 32 562 326 581 379\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:52] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 33 614 453 662 520\n",
"Frame N 33 518 361 555 412\n",
"Frame N 33 3 269 43 323\n",
"Frame N 33 878 312 909 358\n",
"Frame N 33 710 384 734 436\n",
"Frame N 33 568 326 594 381\n",
"Frame N 33 795 282 818 326\n",
"Frame N 33 1019 334 1043 371\n",
"Frame N 33 641 301 657 351\n",
"Frame N 33 1191 252 1216 296\n",
"Frame N 33 680 332 704 386\n",
"Frame N 33 726 423 752 478\n",
"Frame N 33 675 330 711 386\n",
"Frame N 33 725 422 765 479\n",
"Frame N 33 986 285 1003 331\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:52] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 34 603 453 662 520\n",
"Frame N 34 11 269 50 322\n",
"Frame N 34 520 360 558 410\n",
"Frame N 34 1196 253 1225 298\n",
"Frame N 34 1022 337 1041 382\n",
"Frame N 34 569 326 590 380\n",
"Frame N 34 879 310 915 359\n",
"Frame N 34 988 284 1012 331\n",
"Frame N 34 643 302 663 354\n",
"Frame N 34 727 425 751 478\n",
"Frame N 34 716 384 732 435\n",
"Frame N 34 684 333 709 384\n",
"Frame N 34 800 283 818 329\n",
"Frame N 34 680 332 712 388\n",
"Frame N 34 726 425 766 480\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:52] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 35 603 453 653 519\n",
"Frame N 35 19 271 59 323\n",
"Frame N 35 990 285 1022 331\n",
"Frame N 35 1023 339 1041 386\n",
"Frame N 35 569 325 597 380\n",
"Frame N 35 1200 252 1232 299\n",
"Frame N 35 800 283 823 331\n",
"Frame N 35 521 360 558 412\n",
"Frame N 35 645 302 668 355\n",
"Frame N 35 729 429 752 486\n",
"Frame N 35 691 333 709 381\n",
"Frame N 35 876 311 915 363\n",
"Frame N 35 716 384 733 427\n",
"Frame N 35 877 311 904 363\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:52] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 36 603 453 653 519\n",
"Frame N 36 19 271 59 323\n",
"Frame N 36 990 285 1022 331\n",
"Frame N 36 1023 339 1041 386\n",
"Frame N 36 569 325 597 380\n",
"Frame N 36 1200 252 1232 300\n",
"Frame N 36 522 360 558 412\n",
"Frame N 36 800 283 823 331\n",
"Frame N 36 645 302 668 355\n",
"Frame N 36 691 333 709 381\n",
"Frame N 36 729 429 752 486\n",
"Frame N 36 876 311 916 363\n",
"Frame N 36 716 384 733 428\n",
"Frame N 36 877 311 900 363\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:53] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 37 31 271 65 324\n",
"Frame N 37 1021 339 1048 385\n",
"Frame N 37 607 453 642 523\n",
"Frame N 37 992 286 1026 332\n",
"Frame N 37 693 332 711 388\n",
"Frame N 37 647 304 676 355\n",
"Frame N 37 879 312 917 366\n",
"Frame N 37 1202 255 1237 304\n",
"Frame N 37 1203 255 1228 303\n",
"Frame N 37 569 325 593 377\n",
"Frame N 37 715 385 733 418\n",
"Frame N 37 706 384 735 439\n",
"Frame N 37 802 282 822 325\n",
"Frame N 37 530 359 556 413\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:53] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 38 1019 339 1057 389\n",
"Frame N 38 605 454 633 524\n",
"Frame N 38 42 271 71 323\n",
"Frame N 38 996 287 1025 332\n",
"Frame N 38 570 325 593 379\n",
"Frame N 38 693 331 712 371\n",
"Frame N 38 1209 257 1239 306\n",
"Frame N 38 648 304 673 353\n",
"Frame N 38 884 314 908 365\n",
"Frame N 38 721 426 762 483\n",
"Frame N 38 711 386 733 425\n",
"Frame N 38 535 362 556 415\n",
"Frame N 38 706 386 735 440\n",
"Frame N 38 802 283 827 326\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:53] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 39 599 452 635 526\n",
"Frame N 39 1017 342 1063 390\n",
"Frame N 39 49 271 74 324\n",
"Frame N 39 535 361 563 413\n",
"Frame N 39 885 316 905 368\n",
"Frame N 39 716 426 764 480\n",
"Frame N 39 694 330 717 380\n",
"Frame N 39 571 326 594 379\n",
"Frame N 39 650 304 670 351\n",
"Frame N 39 1001 289 1019 332\n",
"Frame N 39 1216 259 1237 308\n",
"Frame N 39 803 282 835 325\n",
"Frame N 39 710 386 731 423\n",
"Frame N 39 704 386 734 440\n",
"Frame N 39 521 361 565 414\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:53] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 40 594 452 638 524\n",
"Frame N 40 56 271 82 324\n",
"Frame N 40 526 363 570 413\n",
"Frame N 40 1020 343 1061 392\n",
"Frame N 40 884 319 915 370\n",
"Frame N 40 1003 289 1023 334\n",
"Frame N 40 692 331 721 385\n",
"Frame N 40 808 281 834 327\n",
"Frame N 40 574 328 594 380\n",
"Frame N 40 712 427 759 479\n",
"Frame N 40 653 305 670 350\n",
"Frame N 40 1220 260 1239 310\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:54] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 41 584 450 641 518\n",
"Frame N 41 62 271 91 326\n",
"Frame N 41 529 365 572 413\n",
"Frame N 41 883 322 918 367\n",
"Frame N 41 1027 347 1059 398\n",
"Frame N 41 1005 290 1024 332\n",
"Frame N 41 693 332 721 384\n",
"Frame N 41 577 330 594 383\n",
"Frame N 41 1222 262 1250 309\n",
"Frame N 41 810 281 829 327\n",
"Frame N 41 716 429 737 482\n",
"Frame N 41 656 307 672 350\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:54] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 42 583 450 641 518\n",
"Frame N 42 529 365 572 413\n",
"Frame N 42 62 271 91 325\n",
"Frame N 42 883 322 918 367\n",
"Frame N 42 1005 290 1024 332\n",
"Frame N 42 1027 347 1059 399\n",
"Frame N 42 692 332 721 384\n",
"Frame N 42 577 330 594 383\n",
"Frame N 42 1222 262 1250 309\n",
"Frame N 42 810 281 829 327\n",
"Frame N 42 716 429 737 483\n",
"Frame N 42 656 307 672 350\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:55] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 43 1005 292 1035 338\n",
"Frame N 43 70 271 97 325\n",
"Frame N 43 881 323 921 370\n",
"Frame N 43 1224 263 1258 309\n",
"Frame N 43 1034 351 1056 401\n",
"Frame N 43 535 365 572 415\n",
"Frame N 43 580 451 623 515\n",
"Frame N 43 580 329 598 383\n",
"Frame N 43 811 284 831 328\n",
"Frame N 43 698 333 722 384\n",
"Frame N 43 659 308 678 360\n",
"Frame N 43 715 427 737 482\n",
"Frame N 43 705 385 730 439\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:55] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 44 1008 294 1041 340\n",
"Frame N 44 1037 353 1055 402\n",
"Frame N 44 585 452 614 522\n",
"Frame N 44 76 273 105 325\n",
"Frame N 44 810 285 835 331\n",
"Frame N 44 882 322 916 372\n",
"Frame N 44 660 310 682 360\n",
"Frame N 44 1229 265 1258 309\n",
"Frame N 44 579 331 600 385\n",
"Frame N 44 883 322 906 371\n",
"Frame N 44 542 367 570 414\n",
"Frame N 44 707 384 732 444\n",
"Frame N 44 711 426 740 485\n",
"Frame N 44 706 334 722 378\n",
"Frame N 44 704 334 723 387\n",
"Frame N 44 530 367 572 416\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:56] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 45 1035 353 1061 404\n",
"Frame N 45 588 454 610 521\n",
"Frame N 45 579 332 611 385\n",
"Frame N 45 84 275 111 327\n",
"Frame N 45 1232 268 1255 315\n",
"Frame N 45 542 367 567 418\n",
"Frame N 45 809 285 840 329\n",
"Frame N 45 1010 296 1045 344\n",
"Frame N 45 886 324 911 376\n",
"Frame N 45 660 311 687 358\n",
"Frame N 45 711 383 732 435\n",
"Frame N 45 706 427 745 487\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:56] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 46 1035 355 1068 408\n",
"Frame N 46 581 454 605 510\n",
"Frame N 46 661 312 694 362\n",
"Frame N 46 887 327 908 377\n",
"Frame N 46 703 431 727 480\n",
"Frame N 46 1014 299 1039 346\n",
"Frame N 46 1238 269 1259 316\n",
"Frame N 46 548 367 572 419\n",
"Frame N 46 579 332 614 381\n",
"Frame N 46 712 336 726 373\n",
"Frame N 46 92 279 119 323\n",
"Frame N 46 814 287 844 327\n",
"Frame N 46 712 384 732 431\n",
"Frame N 46 710 336 727 386\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:56] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 47 577 453 617 524\n",
"Frame N 47 100 280 127 327\n",
"Frame N 47 549 367 579 419\n",
"Frame N 47 885 329 916 378\n",
"Frame N 47 1033 359 1075 413\n",
"Frame N 47 1245 272 1261 320\n",
"Frame N 47 702 431 726 488\n",
"Frame N 47 1020 301 1038 347\n",
"Frame N 47 662 312 699 361\n",
"Frame N 47 582 335 600 378\n",
"Frame N 47 713 335 730 371\n",
"Frame N 47 818 286 838 333\n",
"Frame N 47 580 335 608 378\n",
"Frame N 47 713 386 734 434\n",
"Frame N 47 712 335 733 389\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:57] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 48 577 453 617 524\n",
"Frame N 48 100 280 127 327\n",
"Frame N 48 550 367 579 419\n",
"Frame N 48 885 329 916 378\n",
"Frame N 48 1033 359 1073 412\n",
"Frame N 48 1245 272 1261 320\n",
"Frame N 48 702 431 726 488\n",
"Frame N 48 1020 301 1038 347\n",
"Frame N 48 662 312 699 362\n",
"Frame N 48 582 335 600 378\n",
"Frame N 48 713 335 730 371\n",
"Frame N 48 818 286 838 333\n",
"Frame N 48 580 335 606 378\n",
"Frame N 48 713 386 734 435\n",
"Frame N 48 711 335 733 390\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:57] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 49 568 454 620 520\n",
"Frame N 49 884 331 923 381\n",
"Frame N 49 1022 303 1039 349\n",
"Frame N 49 545 368 582 419\n",
"Frame N 49 107 281 132 329\n",
"Frame N 49 665 315 685 363\n",
"Frame N 49 585 337 605 379\n",
"Frame N 49 1035 362 1079 416\n",
"Frame N 49 704 433 726 481\n",
"Frame N 49 821 287 837 333\n",
"Frame N 49 1251 275 1267 323\n",
"Frame N 49 713 382 735 442\n",
"Frame N 49 1039 362 1073 402\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:57] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 50 561 454 619 521\n",
"Frame N 50 112 283 140 332\n",
"Frame N 50 549 369 588 422\n",
"Frame N 50 1023 303 1045 349\n",
"Frame N 50 822 287 840 333\n",
"Frame N 50 1045 364 1073 404\n",
"Frame N 50 669 316 687 364\n",
"Frame N 50 883 332 905 380\n",
"Frame N 50 1254 277 1274 324\n",
"Frame N 50 589 337 605 379\n",
"Frame N 50 716 339 743 389\n",
"Frame N 50 719 339 740 384\n",
"Frame N 50 882 332 917 379\n",
"Frame N 50 710 384 733 446\n",
"Frame N 50 703 435 725 493\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:58] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 51 563 455 607 523\n",
"Frame N 51 1025 304 1056 352\n",
"Frame N 51 121 284 148 332\n",
"Frame N 51 699 436 728 493\n",
"Frame N 51 1048 368 1070 426\n",
"Frame N 51 821 287 852 337\n",
"Frame N 51 558 371 588 423\n",
"Frame N 51 593 337 609 389\n",
"Frame N 51 673 318 692 370\n",
"Frame N 51 884 335 905 383\n",
"Frame N 51 1256 279 1278 325\n",
"Frame N 51 591 336 613 389\n",
"Frame N 51 722 341 742 383\n",
"Frame N 51 883 336 918 381\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:58] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 52 1026 306 1061 355\n",
"Frame N 52 570 457 594 527\n",
"Frame N 52 1052 371 1071 429\n",
"Frame N 52 126 287 156 333\n",
"Frame N 52 675 319 694 371\n",
"Frame N 52 886 338 918 391\n",
"Frame N 52 695 437 736 495\n",
"Frame N 52 595 338 613 390\n",
"Frame N 52 711 390 741 444\n",
"Frame N 52 823 289 851 335\n",
"Frame N 52 727 343 744 385\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:59] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 53 567 458 595 528\n",
"Frame N 53 1052 373 1077 429\n",
"Frame N 53 1027 310 1066 360\n",
"Frame N 53 136 286 163 333\n",
"Frame N 53 568 374 595 424\n",
"Frame N 53 826 291 849 336\n",
"Frame N 53 676 319 699 373\n",
"Frame N 53 890 341 912 393\n",
"Frame N 53 729 344 750 394\n",
"Frame N 53 714 391 734 438\n",
"Frame N 53 594 340 619 391\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:59] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 54 567 458 595 528\n",
"Frame N 54 1027 310 1066 360\n",
"Frame N 54 1052 373 1077 429\n",
"Frame N 54 136 287 163 333\n",
"Frame N 54 567 373 596 425\n",
"Frame N 54 827 291 850 337\n",
"Frame N 54 676 319 699 373\n",
"Frame N 54 890 341 912 393\n",
"Frame N 54 729 344 750 394\n",
"Frame N 54 714 391 734 439\n",
"Frame N 54 594 340 619 391\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:59] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 55 563 457 598 530\n",
"Frame N 55 1052 376 1087 431\n",
"Frame N 55 570 375 604 424\n",
"Frame N 55 688 443 736 497\n",
"Frame N 55 1036 313 1057 361\n",
"Frame N 55 143 292 173 338\n",
"Frame N 55 595 341 624 394\n",
"Frame N 55 734 346 750 399\n",
"Frame N 55 715 393 738 441\n",
"Frame N 55 675 323 708 374\n",
"Frame N 55 832 292 849 339\n",
"Frame N 55 890 342 917 396\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:49:59] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 56 558 458 602 525\n",
"Frame N 56 887 344 924 397\n",
"Frame N 56 571 378 608 425\n",
"Frame N 56 691 443 722 499\n",
"Frame N 56 1040 316 1060 365\n",
"Frame N 56 714 393 736 448\n",
"Frame N 56 1052 379 1094 435\n",
"Frame N 56 676 325 713 376\n",
"Frame N 56 597 345 628 394\n",
"Frame N 56 150 292 178 340\n",
"Frame N 56 737 348 753 402\n",
"Frame N 56 833 295 847 339\n",
"Frame N 56 1054 380 1079 433\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:00] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 57 551 459 602 523\n",
"Frame N 57 885 348 927 397\n",
"Frame N 57 690 444 714 503\n",
"Frame N 57 713 396 736 452\n",
"Frame N 57 739 348 759 399\n",
"Frame N 57 1041 319 1060 363\n",
"Frame N 57 834 296 854 343\n",
"Frame N 57 575 378 611 426\n",
"Frame N 57 158 294 181 342\n",
"Frame N 57 1054 384 1080 435\n",
"Frame N 57 1049 385 1087 441\n",
"Frame N 57 676 328 704 377\n",
"Frame N 57 602 348 628 391\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:00] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 58 553 460 586 526\n",
"Frame N 58 1041 319 1069 367\n",
"Frame N 58 832 298 859 346\n",
"Frame N 58 884 347 927 400\n",
"Frame N 58 714 397 739 453\n",
"Frame N 58 685 444 716 501\n",
"Frame N 58 165 294 186 343\n",
"Frame N 58 680 328 702 378\n",
"Frame N 58 740 348 763 396\n",
"Frame N 58 1060 387 1079 429\n",
"Frame N 58 1052 388 1090 450\n",
"Frame N 58 604 347 625 399\n",
"Frame N 58 582 381 612 429\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:00] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 59 1042 322 1076 371\n",
"Frame N 59 553 460 580 530\n",
"Frame N 59 831 299 865 345\n",
"Frame N 59 715 399 738 453\n",
"Frame N 59 741 350 768 400\n",
"Frame N 59 1064 393 1081 442\n",
"Frame N 59 680 445 720 500\n",
"Frame N 59 583 381 609 430\n",
"Frame N 59 887 352 918 403\n",
"Frame N 59 606 353 629 394\n",
"Frame N 59 687 331 703 375\n",
"Frame N 59 173 295 193 347\n",
"Frame N 59 685 330 714 382\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:00] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 60 1042 322 1076 371\n",
"Frame N 60 553 461 581 530\n",
"Frame N 60 832 299 865 345\n",
"Frame N 60 715 399 738 453\n",
"Frame N 60 741 350 768 400\n",
"Frame N 60 680 445 720 500\n",
"Frame N 60 1064 394 1081 441\n",
"Frame N 60 583 381 610 430\n",
"Frame N 60 887 352 918 403\n",
"Frame N 60 173 295 193 347\n",
"Frame N 60 606 353 629 394\n",
"Frame N 60 687 331 704 375\n",
"Frame N 60 684 330 714 382\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:01] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 61 554 462 578 531\n",
"Frame N 61 1043 326 1081 375\n",
"Frame N 61 748 351 771 402\n",
"Frame N 61 715 403 739 456\n",
"Frame N 61 1065 395 1085 456\n",
"Frame N 61 890 355 911 407\n",
"Frame N 61 834 302 863 347\n",
"Frame N 61 179 296 202 348\n",
"Frame N 61 586 381 615 433\n",
"Frame N 61 678 445 704 495\n",
"Frame N 61 689 334 705 384\n",
"Frame N 61 610 354 630 403\n",
"Frame N 61 678 443 713 500\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:01] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 62 550 460 583 531\n",
"Frame N 62 715 405 740 457\n",
"Frame N 62 587 381 623 434\n",
"Frame N 62 1065 400 1088 453\n",
"Frame N 62 753 352 773 404\n",
"Frame N 62 841 302 856 348\n",
"Frame N 62 186 300 208 348\n",
"Frame N 62 690 335 711 387\n",
"Frame N 62 674 449 705 506\n",
"Frame N 62 1048 327 1078 378\n",
"Frame N 62 888 356 915 408\n",
"Frame N 62 610 353 632 405\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:01] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 63 546 463 587 528\n",
"Frame N 63 1065 402 1101 461\n",
"Frame N 63 885 358 921 411\n",
"Frame N 63 712 407 743 459\n",
"Frame N 63 677 448 701 507\n",
"Frame N 63 590 382 624 432\n",
"Frame N 63 846 304 858 352\n",
"Frame N 63 192 300 217 350\n",
"Frame N 63 1055 332 1073 380\n",
"Frame N 63 759 354 775 404\n",
"Frame N 63 689 336 719 390\n",
"Frame N 63 612 355 641 410\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:02] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 64 540 463 586 526\n",
"Frame N 64 707 407 746 460\n",
"Frame N 64 689 338 725 391\n",
"Frame N 64 847 303 862 351\n",
"Frame N 64 679 449 697 512\n",
"Frame N 64 884 360 924 410\n",
"Frame N 64 1064 405 1106 462\n",
"Frame N 64 1056 334 1073 382\n",
"Frame N 64 593 383 626 431\n",
"Frame N 64 196 304 223 351\n",
"Frame N 64 761 356 778 405\n",
"Frame N 64 613 356 646 409\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:02] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 65 535 463 581 526\n",
"Frame N 65 688 339 730 392\n",
"Frame N 65 847 305 869 354\n",
"Frame N 65 707 408 749 461\n",
"Frame N 65 879 362 905 416\n",
"Frame N 65 763 357 785 411\n",
"Frame N 65 1057 335 1078 384\n",
"Frame N 65 1061 409 1107 468\n",
"Frame N 65 673 450 700 510\n",
"Frame N 65 1062 409 1092 468\n",
"Frame N 65 200 308 229 356\n",
"Frame N 65 595 384 625 432\n",
"Frame N 65 616 358 644 406\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:02] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 66 535 463 582 526\n",
"Frame N 66 687 339 730 391\n",
"Frame N 66 847 305 869 354\n",
"Frame N 66 706 408 750 461\n",
"Frame N 66 763 357 785 411\n",
"Frame N 66 879 362 905 416\n",
"Frame N 66 1057 335 1078 384\n",
"Frame N 66 1061 409 1108 468\n",
"Frame N 66 1062 409 1093 468\n",
"Frame N 66 673 450 700 510\n",
"Frame N 66 200 308 229 356\n",
"Frame N 66 595 384 625 432\n",
"Frame N 66 617 358 646 406\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:02] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 67 540 463 570 531\n",
"Frame N 67 1056 336 1089 385\n",
"Frame N 67 845 307 875 355\n",
"Frame N 67 764 359 791 411\n",
"Frame N 67 687 341 731 395\n",
"Frame N 67 669 451 707 509\n",
"Frame N 67 708 410 749 465\n",
"Frame N 67 882 365 911 419\n",
"Frame N 67 884 366 904 416\n",
"Frame N 67 1061 412 1098 474\n",
"Frame N 67 598 389 626 435\n",
"Frame N 67 204 309 234 358\n",
"Frame N 67 620 362 646 407\n",
"Frame N 67 1068 413 1091 472\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:03] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 68 1057 338 1092 388\n",
"Frame N 68 597 390 633 437\n",
"Frame N 68 537 464 562 535\n",
"Frame N 68 720 412 745 468\n",
"Frame N 68 664 452 711 507\n",
"Frame N 68 848 308 876 356\n",
"Frame N 68 768 360 792 410\n",
"Frame N 68 1071 416 1095 477\n",
"Frame N 68 1070 416 1104 479\n",
"Frame N 68 885 367 909 423\n",
"Frame N 68 208 313 237 360\n",
"Frame N 68 690 344 725 396\n",
"Frame N 68 623 365 637 407\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:03] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 69 533 464 565 535\n",
"Frame N 69 596 391 638 441\n",
"Frame N 69 660 455 708 511\n",
"Frame N 69 1055 342 1097 394\n",
"Frame N 69 723 413 743 471\n",
"Frame N 69 852 311 874 359\n",
"Frame N 69 1073 420 1094 482\n",
"Frame N 69 884 371 909 425\n",
"Frame N 69 214 316 244 362\n",
"Frame N 69 771 361 795 411\n",
"Frame N 69 693 347 725 401\n",
"Frame N 69 625 364 642 408\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:03] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 70 532 464 567 534\n",
"Frame N 70 665 454 692 514\n",
"Frame N 70 879 373 916 427\n",
"Frame N 70 698 349 718 400\n",
"Frame N 70 1073 422 1095 483\n",
"Frame N 70 596 395 637 444\n",
"Frame N 70 725 411 746 472\n",
"Frame N 70 856 311 872 359\n",
"Frame N 70 1060 344 1081 397\n",
"Frame N 70 627 363 645 413\n",
"Frame N 70 220 319 251 364\n",
"Frame N 70 774 364 799 416\n",
"Frame N 70 1060 344 1094 396\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:03] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 71 524 464 568 530\n",
"Frame N 71 1071 424 1105 486\n",
"Frame N 71 663 456 687 515\n",
"Frame N 71 876 374 917 424\n",
"Frame N 71 698 349 719 404\n",
"Frame N 71 779 365 802 417\n",
"Frame N 71 601 397 624 444\n",
"Frame N 71 721 411 750 473\n",
"Frame N 71 855 313 873 361\n",
"Frame N 71 628 363 649 417\n",
"Frame N 71 227 319 260 365\n",
"Frame N 71 1066 347 1087 398\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:04] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 72 524 464 568 530\n",
"Frame N 72 1071 424 1105 486\n",
"Frame N 72 663 456 687 515\n",
"Frame N 72 876 374 917 424\n",
"Frame N 72 698 349 719 404\n",
"Frame N 72 778 365 802 417\n",
"Frame N 72 601 397 623 444\n",
"Frame N 72 721 411 750 473\n",
"Frame N 72 855 313 873 361\n",
"Frame N 72 628 363 649 417\n",
"Frame N 72 227 319 260 365\n",
"Frame N 72 1066 347 1087 398\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:04] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 73 1068 424 1112 487\n",
"Frame N 73 520 464 564 529\n",
"Frame N 73 659 455 686 516\n",
"Frame N 73 725 412 753 472\n",
"Frame N 73 695 352 726 406\n",
"Frame N 73 854 313 877 364\n",
"Frame N 73 604 398 626 447\n",
"Frame N 73 782 366 801 420\n",
"Frame N 73 627 363 655 417\n",
"Frame N 73 1068 349 1086 400\n",
"Frame N 73 236 324 266 367\n",
"Frame N 73 872 378 914 427\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:04] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 74 520 466 555 532\n",
"Frame N 74 695 351 731 405\n",
"Frame N 74 1063 427 1116 490\n",
"Frame N 74 728 411 755 470\n",
"Frame N 74 784 365 806 421\n",
"Frame N 74 852 313 879 363\n",
"Frame N 74 606 401 631 448\n",
"Frame N 74 1066 350 1089 397\n",
"Frame N 74 629 365 658 415\n",
"Frame N 74 1255 583 1283 653\n",
"Frame N 74 874 378 908 431\n",
"Frame N 74 655 453 692 516\n",
"Frame N 74 244 325 273 368\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:04] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 75 520 465 546 535\n",
"Frame N 75 1064 352 1097 401\n",
"Frame N 75 1061 430 1117 495\n",
"Frame N 75 786 365 807 418\n",
"Frame N 75 732 410 754 471\n",
"Frame N 75 854 316 880 363\n",
"Frame N 75 650 453 683 508\n",
"Frame N 75 606 400 638 448\n",
"Frame N 75 1251 584 1282 656\n",
"Frame N 75 876 381 897 433\n",
"Frame N 75 249 324 279 371\n",
"Frame N 75 632 366 657 408\n",
"Frame N 75 697 351 720 395\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:05] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 76 1064 352 1101 404\n",
"Frame N 76 1064 433 1114 500\n",
"Frame N 76 519 465 545 534\n",
"Frame N 76 1255 585 1281 658\n",
"Frame N 76 787 365 812 419\n",
"Frame N 76 603 398 639 447\n",
"Frame N 76 734 411 754 472\n",
"Frame N 76 645 454 675 511\n",
"Frame N 76 632 368 654 410\n",
"Frame N 76 859 317 878 364\n",
"Frame N 76 693 354 718 401\n",
"Frame N 76 256 324 285 372\n",
"Frame N 76 645 453 687 510\n",
"Frame N 76 871 379 895 434\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:05] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 77 512 463 549 530\n",
"Frame N 77 786 365 818 419\n",
"Frame N 77 1061 354 1103 407\n",
"Frame N 77 602 398 638 443\n",
"Frame N 77 643 456 684 517\n",
"Frame N 77 1071 437 1103 504\n",
"Frame N 77 733 412 752 472\n",
"Frame N 77 633 369 653 414\n",
"Frame N 77 862 318 875 364\n",
"Frame N 77 699 355 723 404\n",
"Frame N 77 1255 586 1278 660\n",
"Frame N 77 867 380 899 436\n",
"Frame N 77 262 325 289 373\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:05] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 78 512 462 548 531\n",
"Frame N 78 1060 354 1103 407\n",
"Frame N 78 786 365 818 419\n",
"Frame N 78 643 456 684 517\n",
"Frame N 78 602 398 638 443\n",
"Frame N 78 1070 437 1104 504\n",
"Frame N 78 733 412 752 472\n",
"Frame N 78 633 369 653 414\n",
"Frame N 78 862 318 875 364\n",
"Frame N 78 699 355 722 404\n",
"Frame N 78 1255 586 1278 660\n",
"Frame N 78 867 380 899 436\n",
"Frame N 78 262 326 289 373\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:06] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 79 505 462 551 528\n",
"Frame N 79 732 415 755 474\n",
"Frame N 79 646 456 667 517\n",
"Frame N 79 634 370 654 423\n",
"Frame N 79 699 355 721 410\n",
"Frame N 79 1070 440 1093 506\n",
"Frame N 79 603 399 632 444\n",
"Frame N 79 1062 356 1092 411\n",
"Frame N 79 787 367 818 418\n",
"Frame N 79 862 318 877 369\n",
"Frame N 79 863 382 885 431\n",
"Frame N 79 267 326 292 373\n",
"Frame N 79 1247 585 1280 666\n",
"Frame N 79 862 381 900 433\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:06] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 80 495 462 547 529\n",
"Frame N 80 640 456 662 517\n",
"Frame N 80 729 417 759 475\n",
"Frame N 80 860 319 879 368\n",
"Frame N 80 1067 440 1094 506\n",
"Frame N 80 699 355 717 411\n",
"Frame N 80 604 400 631 447\n",
"Frame N 80 1242 584 1278 653\n",
"Frame N 80 856 383 878 435\n",
"Frame N 80 1068 358 1089 411\n",
"Frame N 80 789 367 815 418\n",
"Frame N 80 635 371 652 425\n",
"Frame N 80 269 329 296 376\n",
"Frame N 80 634 385 652 425\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:06] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 81 493 462 537 529\n",
"Frame N 81 1062 440 1100 509\n",
"Frame N 81 633 457 667 519\n",
"Frame N 81 1235 585 1279 654\n",
"Frame N 81 732 417 756 476\n",
"Frame N 81 856 320 882 370\n",
"Frame N 81 696 355 722 411\n",
"Frame N 81 604 400 624 448\n",
"Frame N 81 1067 359 1084 413\n",
"Frame N 81 635 372 653 425\n",
"Frame N 81 273 328 302 377\n",
"Frame N 81 798 368 816 421\n",
"Frame N 81 852 386 883 437\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:06] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 82 495 463 526 530\n",
"Frame N 82 1058 442 1102 509\n",
"Frame N 82 627 460 667 512\n",
"Frame N 82 732 420 753 477\n",
"Frame N 82 1225 584 1265 650\n",
"Frame N 82 602 401 624 449\n",
"Frame N 82 1063 359 1089 413\n",
"Frame N 82 690 356 725 411\n",
"Frame N 82 798 368 815 423\n",
"Frame N 82 854 321 881 367\n",
"Frame N 82 852 386 881 441\n",
"Frame N 82 633 375 654 425\n",
"Frame N 82 277 329 308 378\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:07] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 83 490 463 520 530\n",
"Frame N 83 1224 583 1263 653\n",
"Frame N 83 620 461 668 511\n",
"Frame N 83 1060 360 1093 413\n",
"Frame N 83 597 404 625 448\n",
"Frame N 83 849 388 872 444\n",
"Frame N 83 732 418 755 478\n",
"Frame N 83 800 368 817 422\n",
"Frame N 83 1052 443 1104 512\n",
"Frame N 83 690 357 727 410\n",
"Frame N 83 1052 444 1082 512\n",
"Frame N 83 859 322 879 368\n",
"Frame N 83 631 377 653 424\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:07] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 84 489 463 520 530\n",
"Frame N 84 1224 583 1263 653\n",
"Frame N 84 620 460 668 511\n",
"Frame N 84 1060 360 1093 413\n",
"Frame N 84 597 404 625 448\n",
"Frame N 84 732 418 754 478\n",
"Frame N 84 849 388 872 444\n",
"Frame N 84 800 368 817 422\n",
"Frame N 84 1052 443 1104 512\n",
"Frame N 84 690 357 727 410\n",
"Frame N 84 1052 444 1083 512\n",
"Frame N 84 859 321 879 368\n",
"Frame N 84 631 377 653 424\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:07] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 85 486 461 517 532\n",
"Frame N 85 842 391 875 443\n",
"Frame N 85 1059 361 1095 414\n",
"Frame N 85 1231 584 1255 655\n",
"Frame N 85 619 460 659 511\n",
"Frame N 85 731 416 755 477\n",
"Frame N 85 799 368 823 426\n",
"Frame N 85 1050 449 1097 515\n",
"Frame N 85 860 323 877 370\n",
"Frame N 85 631 378 653 427\n",
"Frame N 85 689 357 726 409\n",
"Frame N 85 594 405 623 445\n",
"Frame N 85 287 332 317 381\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:07] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 86 481 460 516 529\n",
"Frame N 86 1226 582 1257 657\n",
"Frame N 86 619 457 644 515\n",
"Frame N 86 836 389 875 440\n",
"Frame N 86 1053 363 1096 417\n",
"Frame N 86 860 323 876 370\n",
"Frame N 86 726 416 754 476\n",
"Frame N 86 1056 451 1088 520\n",
"Frame N 86 801 368 823 425\n",
"Frame N 86 634 379 653 428\n",
"Frame N 86 592 406 623 452\n",
"Frame N 86 292 335 323 381\n",
"Frame N 86 692 357 712 407\n",
"Frame N 86 691 358 723 409\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:08] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 87 474 459 516 525\n",
"Frame N 87 1221 580 1259 658\n",
"Frame N 87 618 456 640 516\n",
"Frame N 87 722 415 755 478\n",
"Frame N 87 858 322 879 371\n",
"Frame N 87 826 395 877 443\n",
"Frame N 87 1056 452 1079 520\n",
"Frame N 87 692 358 713 413\n",
"Frame N 87 1056 364 1093 420\n",
"Frame N 87 635 381 655 427\n",
"Frame N 87 801 369 822 424\n",
"Frame N 87 593 408 624 453\n",
"Frame N 87 297 337 328 382\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:08] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 88 471 460 511 522\n",
"Frame N 88 1052 453 1078 520\n",
"Frame N 88 1217 579 1260 652\n",
"Frame N 88 854 322 884 369\n",
"Frame N 88 731 416 754 476\n",
"Frame N 88 820 395 867 445\n",
"Frame N 88 616 456 639 515\n",
"Frame N 88 1059 368 1079 422\n",
"Frame N 88 635 381 657 429\n",
"Frame N 88 695 358 714 414\n",
"Frame N 88 804 371 822 426\n",
"Frame N 88 302 335 331 382\n",
"Frame N 88 600 410 624 453\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:08] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 89 1046 454 1083 523\n",
"Frame N 89 466 461 502 526\n",
"Frame N 89 1209 577 1263 647\n",
"Frame N 89 726 417 758 477\n",
"Frame N 89 851 322 888 369\n",
"Frame N 89 694 357 713 411\n",
"Frame N 89 1060 368 1078 422\n",
"Frame N 89 610 459 642 513\n",
"Frame N 89 633 382 659 430\n",
"Frame N 89 827 397 848 445\n",
"Frame N 89 826 397 855 446\n",
"Frame N 89 807 373 824 423\n",
"Frame N 89 305 335 336 385\n",
"Frame N 89 595 412 624 455\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:08] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 90 1046 454 1083 523\n",
"Frame N 90 466 461 502 526\n",
"Frame N 90 1209 577 1263 647\n",
"Frame N 90 851 322 888 369\n",
"Frame N 90 726 417 758 477\n",
"Frame N 90 694 357 713 412\n",
"Frame N 90 1060 368 1078 422\n",
"Frame N 90 610 459 642 513\n",
"Frame N 90 633 382 659 429\n",
"Frame N 90 827 397 848 445\n",
"Frame N 90 826 397 855 446\n",
"Frame N 90 806 372 825 428\n",
"Frame N 90 305 335 336 385\n",
"Frame N 90 596 412 624 455\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:09] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 91 1040 455 1085 525\n",
"Frame N 91 724 417 762 475\n",
"Frame N 91 1199 577 1254 647\n",
"Frame N 91 465 461 497 526\n",
"Frame N 91 692 357 718 417\n",
"Frame N 91 809 375 846 450\n",
"Frame N 91 1059 368 1079 419\n",
"Frame N 91 636 384 660 434\n",
"Frame N 91 311 337 343 387\n",
"Frame N 91 855 322 888 368\n",
"Frame N 91 601 456 635 508\n",
"Frame N 91 593 412 629 481\n",
"Frame N 91 592 412 627 456\n",
"Frame N 91 594 411 634 507\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:09] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 92 1032 457 1087 526\n",
"Frame N 92 595 411 634 511\n",
"Frame N 92 723 420 765 475\n",
"Frame N 92 1057 369 1083 422\n",
"Frame N 92 810 374 844 451\n",
"Frame N 92 464 459 492 527\n",
"Frame N 92 691 358 721 415\n",
"Frame N 92 1199 579 1245 649\n",
"Frame N 92 317 341 348 388\n",
"Frame N 92 640 383 662 431\n",
"Frame N 92 859 323 884 371\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:10] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 93 810 375 847 453\n",
"Frame N 93 1054 370 1087 425\n",
"Frame N 93 724 423 763 476\n",
"Frame N 93 596 411 632 513\n",
"Frame N 93 1031 459 1086 528\n",
"Frame N 93 461 459 488 521\n",
"Frame N 93 1204 579 1237 653\n",
"Frame N 93 690 359 726 413\n",
"Frame N 93 320 341 354 391\n",
"Frame N 93 862 323 879 373\n",
"Frame N 93 640 385 665 436\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:10] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 94 456 457 489 524\n",
"Frame N 94 1050 372 1091 429\n",
"Frame N 94 1200 579 1228 653\n",
"Frame N 94 724 424 760 477\n",
"Frame N 94 1037 464 1074 530\n",
"Frame N 94 690 360 725 412\n",
"Frame N 94 800 372 847 454\n",
"Frame N 94 863 323 878 375\n",
"Frame N 94 328 340 358 391\n",
"Frame N 94 643 385 669 430\n",
"Frame N 94 611 410 637 463\n",
"Frame N 94 600 462 624 513\n",
"Frame N 94 806 373 836 442\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:10] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 95 446 457 487 522\n",
"Frame N 95 1196 578 1232 654\n",
"Frame N 95 729 426 760 479\n",
"Frame N 95 1041 462 1064 535\n",
"Frame N 95 331 342 364 392\n",
"Frame N 95 863 322 879 371\n",
"Frame N 95 1048 376 1083 431\n",
"Frame N 95 691 360 713 414\n",
"Frame N 95 789 373 845 453\n",
"Frame N 95 595 457 618 514\n",
"Frame N 95 616 407 648 466\n",
"Frame N 95 689 359 721 414\n",
"Frame N 95 650 385 670 421\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:11] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 96 446 457 487 522\n",
"Frame N 96 1196 577 1232 654\n",
"Frame N 96 729 426 760 479\n",
"Frame N 96 1041 462 1063 534\n",
"Frame N 96 863 322 879 371\n",
"Frame N 96 331 342 364 392\n",
"Frame N 96 1048 376 1083 431\n",
"Frame N 96 595 457 618 514\n",
"Frame N 96 691 360 713 414\n",
"Frame N 96 789 373 845 453\n",
"Frame N 96 616 407 647 466\n",
"Frame N 96 650 385 670 422\n",
"Frame N 96 689 359 722 414\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:11] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 97 443 457 486 521\n",
"Frame N 97 1191 576 1234 648\n",
"Frame N 97 1038 465 1060 535\n",
"Frame N 97 1051 376 1078 432\n",
"Frame N 97 729 426 762 477\n",
"Frame N 97 591 454 618 515\n",
"Frame N 97 861 323 882 373\n",
"Frame N 97 692 363 712 411\n",
"Frame N 97 336 341 369 393\n",
"Frame N 97 621 405 652 459\n",
"Frame N 97 788 404 820 458\n",
"Frame N 97 821 373 840 419\n",
"Frame N 97 654 387 672 420\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:11] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 98 1030 465 1065 535\n",
"Frame N 98 443 458 479 523\n",
"Frame N 98 1186 576 1235 645\n",
"Frame N 98 735 426 763 475\n",
"Frame N 98 588 454 618 512\n",
"Frame N 98 1055 378 1076 431\n",
"Frame N 98 625 404 656 458\n",
"Frame N 98 862 323 881 372\n",
"Frame N 98 339 344 374 392\n",
"Frame N 98 694 363 711 415\n",
"Frame N 98 796 408 815 455\n",
"Frame N 98 823 374 841 425\n",
"Frame N 98 793 407 819 457\n",
"Frame N 98 653 390 676 423\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:12] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 99 1027 465 1069 535\n",
"Frame N 99 434 457 471 525\n",
"Frame N 99 585 451 619 510\n",
"Frame N 99 1054 379 1071 434\n",
"Frame N 99 738 427 764 478\n",
"Frame N 99 863 324 880 371\n",
"Frame N 99 347 343 378 393\n",
"Frame N 99 794 412 814 459\n",
"Frame N 99 1180 575 1221 643\n",
"Frame N 99 693 363 710 415\n",
"Frame N 99 631 401 659 458\n",
"Frame N 99 826 375 843 428\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:12] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 100 1023 466 1070 535\n",
"Frame N 100 432 457 468 526\n",
"Frame N 100 584 451 614 511\n",
"Frame N 100 1052 379 1074 434\n",
"Frame N 100 739 427 766 478\n",
"Frame N 100 1181 577 1211 644\n",
"Frame N 100 864 324 879 371\n",
"Frame N 100 349 346 381 393\n",
"Frame N 100 636 402 661 459\n",
"Frame N 100 785 413 810 459\n",
"Frame N 100 691 363 713 419\n",
"Frame N 100 829 374 844 418\n",
"Frame N 100 828 373 846 429\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:12] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 101 432 455 466 524\n",
"Frame N 101 1050 380 1081 437\n",
"Frame N 101 584 451 608 512\n",
"Frame N 101 1186 578 1210 647\n",
"Frame N 101 740 424 769 478\n",
"Frame N 101 779 409 813 462\n",
"Frame N 101 864 325 879 373\n",
"Frame N 101 1019 468 1069 534\n",
"Frame N 101 831 373 849 429\n",
"Frame N 101 640 406 670 460\n",
"Frame N 101 690 362 721 418\n",
"Frame N 101 356 346 384 393\n",
"Frame N 101 664 393 683 425\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:13] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 102 432 455 466 524\n",
"Frame N 102 1050 379 1081 437\n",
"Frame N 102 584 451 608 512\n",
"Frame N 102 1186 578 1210 647\n",
"Frame N 102 740 424 769 478\n",
"Frame N 102 779 409 812 462\n",
"Frame N 102 864 325 879 374\n",
"Frame N 102 1019 468 1070 534\n",
"Frame N 102 831 373 849 429\n",
"Frame N 102 640 406 670 460\n",
"Frame N 102 355 346 384 393\n",
"Frame N 102 690 362 721 418\n",
"Frame N 102 664 393 683 425\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:13] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 103 1044 380 1084 439\n",
"Frame N 103 429 456 465 519\n",
"Frame N 103 1183 576 1211 649\n",
"Frame N 103 742 424 771 476\n",
"Frame N 103 361 348 390 396\n",
"Frame N 103 864 324 880 373\n",
"Frame N 103 582 453 606 511\n",
"Frame N 103 834 374 850 430\n",
"Frame N 103 1022 468 1059 538\n",
"Frame N 103 773 411 811 462\n",
"Frame N 103 647 416 676 460\n",
"Frame N 103 692 364 709 410\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:13] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 104 419 455 466 516\n",
"Frame N 104 1180 575 1215 651\n",
"Frame N 104 1044 381 1086 440\n",
"Frame N 104 744 424 777 479\n",
"Frame N 104 365 351 396 397\n",
"Frame N 104 1025 472 1053 541\n",
"Frame N 104 580 452 607 510\n",
"Frame N 104 652 406 680 463\n",
"Frame N 104 836 375 854 430\n",
"Frame N 104 865 324 883 376\n",
"Frame N 104 776 412 795 457\n",
"Frame N 104 693 365 708 410\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:14] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 105 1177 575 1218 647\n",
"Frame N 105 415 455 461 515\n",
"Frame N 105 1024 474 1048 544\n",
"Frame N 105 864 324 888 377\n",
"Frame N 105 1048 383 1084 443\n",
"Frame N 105 576 451 606 509\n",
"Frame N 105 749 424 778 480\n",
"Frame N 105 370 355 401 399\n",
"Frame N 105 839 377 855 431\n",
"Frame N 105 658 407 686 465\n",
"Frame N 105 692 366 709 416\n",
"Frame N 105 772 415 794 477\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:14] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 106 1173 575 1219 641\n",
"Frame N 106 1020 475 1054 544\n",
"Frame N 106 414 457 459 521\n",
"Frame N 106 575 450 606 509\n",
"Frame N 106 377 357 407 400\n",
"Frame N 106 864 329 892 376\n",
"Frame N 106 1053 387 1071 445\n",
"Frame N 106 752 419 791 481\n",
"Frame N 106 843 379 859 435\n",
"Frame N 106 664 405 694 467\n",
"Frame N 106 691 368 709 418\n",
"Frame N 106 763 416 792 481\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:14] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 107 1015 476 1058 544\n",
"Frame N 107 416 458 460 524\n",
"Frame N 107 756 419 788 485\n",
"Frame N 107 575 451 605 507\n",
"Frame N 107 1170 575 1206 642\n",
"Frame N 107 1056 389 1077 449\n",
"Frame N 107 846 379 865 437\n",
"Frame N 107 669 405 699 468\n",
"Frame N 107 378 358 412 403\n",
"Frame N 107 866 329 893 374\n",
"Frame N 107 688 368 712 424\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:15] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 108 1015 476 1058 544\n",
"Frame N 108 416 458 460 524\n",
"Frame N 108 756 419 788 485\n",
"Frame N 108 575 451 605 507\n",
"Frame N 108 1170 575 1207 642\n",
"Frame N 108 1056 389 1077 449\n",
"Frame N 108 846 379 865 437\n",
"Frame N 108 669 405 699 468\n",
"Frame N 108 865 329 894 375\n",
"Frame N 108 378 358 412 403\n",
"Frame N 108 688 368 712 424\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:15] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 109 1007 478 1059 542\n",
"Frame N 109 420 458 460 523\n",
"Frame N 109 1170 575 1208 644\n",
"Frame N 109 761 417 790 485\n",
"Frame N 109 1054 390 1076 450\n",
"Frame N 109 574 451 602 509\n",
"Frame N 109 849 378 872 436\n",
"Frame N 109 868 329 896 377\n",
"Frame N 109 383 359 416 405\n",
"Frame N 109 675 404 714 468\n",
"Frame N 109 676 370 719 468\n",
"Frame N 109 689 368 715 423\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:15] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 110 754 417 791 487\n",
"Frame N 110 417 457 450 524\n",
"Frame N 110 1005 479 1058 542\n",
"Frame N 110 1052 391 1080 448\n",
"Frame N 110 1173 576 1202 649\n",
"Frame N 110 850 378 878 437\n",
"Frame N 110 573 454 599 512\n",
"Frame N 110 871 332 893 379\n",
"Frame N 110 385 363 421 404\n",
"Frame N 110 681 372 719 467\n",
"Frame N 110 679 409 716 468\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:16] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 111 1052 391 1086 449\n",
"Frame N 111 411 456 445 523\n",
"Frame N 111 571 453 603 514\n",
"Frame N 111 1172 576 1198 651\n",
"Frame N 111 855 380 879 436\n",
"Frame N 111 758 421 792 488\n",
"Frame N 111 684 410 715 469\n",
"Frame N 111 874 332 888 380\n",
"Frame N 111 1007 482 1054 547\n",
"Frame N 111 1008 482 1035 545\n",
"Frame N 111 392 366 422 408\n",
"Frame N 111 748 420 790 484\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:16] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 112 399 456 443 521\n",
"Frame N 112 1049 392 1090 452\n",
"Frame N 112 566 453 608 511\n",
"Frame N 112 858 382 880 436\n",
"Frame N 112 687 372 726 470\n",
"Frame N 112 743 422 779 483\n",
"Frame N 112 1169 575 1203 651\n",
"Frame N 112 687 404 725 470\n",
"Frame N 112 875 333 890 379\n",
"Frame N 112 1015 485 1048 546\n",
"Frame N 112 1015 485 1035 545\n",
"Frame N 112 770 427 797 488\n",
"Frame N 112 397 369 426 409\n",
"Frame N 112 689 370 715 451\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:16] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 113 395 457 442 520\n",
"Frame N 113 1048 394 1092 456\n",
"Frame N 113 1167 573 1209 647\n",
"Frame N 113 861 381 887 439\n",
"Frame N 113 876 332 897 381\n",
"Frame N 113 1012 488 1033 549\n",
"Frame N 113 752 423 775 479\n",
"Frame N 113 773 428 799 488\n",
"Frame N 113 560 453 598 506\n",
"Frame N 113 694 406 726 469\n",
"Frame N 113 689 374 725 469\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:16] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 114 395 457 442 520\n",
"Frame N 114 1047 394 1092 456\n",
"Frame N 114 1167 573 1209 647\n",
"Frame N 114 861 381 887 439\n",
"Frame N 114 876 332 897 382\n",
"Frame N 114 1012 488 1033 548\n",
"Frame N 114 752 423 775 479\n",
"Frame N 114 773 428 799 488\n",
"Frame N 114 560 453 597 506\n",
"Frame N 114 695 406 726 469\n",
"Frame N 114 689 374 725 469\n",
"Frame N 114 402 372 431 410\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:17] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 115 395 457 440 522\n",
"Frame N 115 1165 573 1210 642\n",
"Frame N 115 1007 488 1042 552\n",
"Frame N 115 1053 396 1085 455\n",
"Frame N 115 876 333 900 384\n",
"Frame N 115 776 428 802 489\n",
"Frame N 115 565 453 596 505\n",
"Frame N 115 866 380 886 438\n",
"Frame N 115 753 423 774 485\n",
"Frame N 115 696 408 724 471\n",
"Frame N 115 405 371 435 412\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:17] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 116 400 459 440 522\n",
"Frame N 116 1003 489 1046 552\n",
"Frame N 116 782 429 806 491\n",
"Frame N 116 875 333 904 384\n",
"Frame N 116 566 453 590 510\n",
"Frame N 116 1057 398 1080 458\n",
"Frame N 116 1159 574 1201 641\n",
"Frame N 116 753 423 768 486\n",
"Frame N 116 868 383 887 436\n",
"Frame N 116 697 410 727 472\n",
"Frame N 116 408 371 438 416\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:17] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 117 404 459 437 526\n",
"Frame N 117 995 493 1049 554\n",
"Frame N 117 748 424 770 486\n",
"Frame N 117 702 411 735 474\n",
"Frame N 117 563 453 585 509\n",
"Frame N 117 1158 575 1200 642\n",
"Frame N 117 786 429 812 488\n",
"Frame N 117 411 374 444 421\n",
"Frame N 117 1060 400 1077 461\n",
"Frame N 117 873 380 898 438\n",
"Frame N 117 879 334 902 383\n",
"Frame N 117 689 374 704 417\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:17] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 118 407 456 436 526\n",
"Frame N 118 1165 576 1192 647\n",
"Frame N 118 1059 400 1079 460\n",
"Frame N 118 412 376 445 425\n",
"Frame N 118 793 429 815 488\n",
"Frame N 118 556 452 589 509\n",
"Frame N 118 704 412 738 474\n",
"Frame N 118 685 374 708 428\n",
"Frame N 118 991 494 1050 557\n",
"Frame N 118 875 382 901 438\n",
"Frame N 118 742 429 774 488\n",
"Frame N 118 882 337 901 383\n",
"Frame N 118 747 426 770 480\n",
"Frame N 118 527 491 538 503\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:18] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 119 403 455 435 524\n",
"Frame N 119 1057 400 1086 461\n",
"Frame N 119 1165 576 1190 649\n",
"Frame N 119 798 428 819 490\n",
"Frame N 119 551 452 591 510\n",
"Frame N 119 737 428 774 490\n",
"Frame N 119 991 496 1044 561\n",
"Frame N 119 878 385 904 439\n",
"Frame N 119 415 381 447 423\n",
"Frame N 119 883 337 900 390\n",
"Frame N 119 682 375 711 425\n",
"Frame N 119 991 497 1023 560\n",
"Frame N 119 705 415 742 479\n",
"Frame N 119 880 336 904 437\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:18] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 120 403 455 435 524\n",
"Frame N 120 1057 400 1086 461\n",
"Frame N 120 1165 576 1190 649\n",
"Frame N 120 798 428 819 490\n",
"Frame N 120 551 452 591 509\n",
"Frame N 120 991 496 1044 561\n",
"Frame N 120 738 428 774 490\n",
"Frame N 120 877 385 904 439\n",
"Frame N 120 414 381 447 423\n",
"Frame N 120 883 337 900 391\n",
"Frame N 120 682 375 711 425\n",
"Frame N 120 991 497 1025 560\n",
"Frame N 120 705 415 742 479\n",
"Frame N 120 880 336 904 437\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:18] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 121 1161 575 1196 651\n",
"Frame N 121 402 454 436 521\n",
"Frame N 121 1055 400 1090 464\n",
"Frame N 121 803 429 823 492\n",
"Frame N 121 411 381 447 428\n",
"Frame N 121 881 386 908 440\n",
"Frame N 121 545 450 576 504\n",
"Frame N 121 735 429 772 490\n",
"Frame N 121 998 498 1018 562\n",
"Frame N 121 997 499 1029 563\n",
"Frame N 121 683 378 704 425\n",
"Frame N 121 712 417 744 489\n",
"Frame N 121 884 336 898 391\n",
"Frame N 121 545 450 590 506\n",
"Frame N 121 512 493 522 504\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:18] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 122 400 454 436 519\n",
"Frame N 122 1051 403 1092 464\n",
"Frame N 122 1162 574 1198 649\n",
"Frame N 122 411 382 448 430\n",
"Frame N 122 543 445 571 505\n",
"Frame N 122 997 501 1018 564\n",
"Frame N 122 807 431 827 494\n",
"Frame N 122 681 380 699 432\n",
"Frame N 122 883 386 912 442\n",
"Frame N 122 728 434 757 495\n",
"Frame N 122 886 334 902 370\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:19] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 123 1159 573 1200 647\n",
"Frame N 123 812 432 831 495\n",
"Frame N 123 403 454 437 523\n",
"Frame N 123 1052 404 1096 466\n",
"Frame N 123 410 383 448 431\n",
"Frame N 123 992 500 1021 566\n",
"Frame N 123 546 446 573 508\n",
"Frame N 123 682 379 699 431\n",
"Frame N 123 883 385 911 443\n",
"Frame N 123 886 334 903 370\n",
"Frame N 123 883 333 907 380\n",
"Frame N 123 731 438 755 496\n",
"Frame N 123 881 365 911 443\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:19] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 124 403 451 438 523\n",
"Frame N 124 1155 573 1202 643\n",
"Frame N 124 815 432 835 497\n",
"Frame N 124 988 502 1026 568\n",
"Frame N 124 543 447 565 510\n",
"Frame N 124 1057 406 1093 466\n",
"Frame N 124 412 385 449 431\n",
"Frame N 124 680 378 698 433\n",
"Frame N 124 1060 407 1085 465\n",
"Frame N 124 884 333 906 387\n",
"Frame N 124 717 414 754 499\n",
"Frame N 124 891 392 913 445\n",
"Frame N 124 884 391 912 446\n",
"Frame N 124 878 333 912 428\n",
"Frame N 124 707 415 725 442\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:19] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 125 402 450 438 523\n",
"Frame N 125 979 504 1030 568\n",
"Frame N 125 535 444 563 513\n",
"Frame N 125 818 432 840 499\n",
"Frame N 125 1149 573 1193 643\n",
"Frame N 125 1059 409 1089 467\n",
"Frame N 125 894 392 912 447\n",
"Frame N 125 676 377 698 434\n",
"Frame N 125 882 335 910 390\n",
"Frame N 125 411 391 449 435\n",
"Frame N 125 719 416 755 499\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:20] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 126 402 450 438 523\n",
"Frame N 126 979 504 1031 568\n",
"Frame N 126 535 444 564 513\n",
"Frame N 126 818 432 840 499\n",
"Frame N 126 1149 573 1191 643\n",
"Frame N 126 1059 409 1089 468\n",
"Frame N 126 894 391 912 446\n",
"Frame N 126 676 377 698 434\n",
"Frame N 126 882 335 910 390\n",
"Frame N 126 721 416 755 499\n",
"Frame N 126 410 390 450 434\n",
"Frame N 126 726 415 751 483\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:20] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 127 973 505 1031 572\n",
"Frame N 127 404 449 437 517\n",
"Frame N 127 1149 575 1186 647\n",
"Frame N 127 527 450 566 510\n",
"Frame N 127 822 433 845 499\n",
"Frame N 127 671 377 701 435\n",
"Frame N 127 721 423 758 501\n",
"Frame N 127 1062 410 1083 471\n",
"Frame N 127 896 390 915 449\n",
"Frame N 127 407 392 450 439\n",
"Frame N 127 883 336 910 392\n",
"Frame N 127 724 416 753 476\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:20] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 128 402 449 435 509\n",
"Frame N 128 711 419 758 504\n",
"Frame N 128 1155 577 1186 651\n",
"Frame N 128 826 433 849 501\n",
"Frame N 128 520 450 564 508\n",
"Frame N 128 1061 411 1084 473\n",
"Frame N 128 666 378 698 435\n",
"Frame N 128 410 393 451 442\n",
"Frame N 128 895 391 923 449\n",
"Frame N 128 967 507 1028 579\n",
"Frame N 128 968 508 1006 579\n",
"Frame N 128 705 418 727 468\n",
"Frame N 128 887 339 906 394\n",
"Frame N 128 721 419 754 500\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:20] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 129 412 396 455 443\n",
"Frame N 129 1059 411 1090 475\n",
"Frame N 129 831 436 852 502\n",
"Frame N 129 1153 577 1181 652\n",
"Frame N 129 896 390 927 450\n",
"Frame N 129 703 420 756 504\n",
"Frame N 129 407 451 435 508\n",
"Frame N 129 662 380 691 437\n",
"Frame N 129 510 453 544 507\n",
"Frame N 129 972 510 1021 586\n",
"Frame N 129 702 418 727 502\n",
"Frame N 129 702 417 726 477\n",
"Frame N 129 974 511 1005 585\n",
"Frame N 129 730 420 755 495\n",
"Frame N 129 510 453 558 507\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:21] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 130 1056 412 1094 477\n",
"Frame N 130 835 438 856 503\n",
"Frame N 130 416 397 457 444\n",
"Frame N 130 507 454 546 511\n",
"Frame N 130 1150 576 1181 656\n",
"Frame N 130 408 455 437 515\n",
"Frame N 130 665 380 689 439\n",
"Frame N 130 733 423 757 496\n",
"Frame N 130 976 512 1013 585\n",
"Frame N 130 897 387 929 449\n",
"Frame N 130 700 418 726 507\n",
"Frame N 130 701 424 736 506\n",
"Frame N 130 888 340 906 392\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:21] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 131 1147 577 1187 654\n",
"Frame N 131 1053 416 1098 478\n",
"Frame N 131 840 439 861 502\n",
"Frame N 131 410 456 438 515\n",
"Frame N 131 736 424 760 487\n",
"Frame N 131 976 516 999 590\n",
"Frame N 131 666 383 685 442\n",
"Frame N 131 508 455 537 510\n",
"Frame N 131 417 399 462 445\n",
"Frame N 131 705 417 732 501\n",
"Frame N 131 898 391 924 450\n",
"Frame N 131 889 339 908 394\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:21] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 132 1147 577 1187 654\n",
"Frame N 132 1053 416 1098 478\n",
"Frame N 132 840 439 861 502\n",
"Frame N 132 410 456 439 515\n",
"Frame N 132 736 424 759 488\n",
"Frame N 132 666 383 685 442\n",
"Frame N 132 976 516 999 590\n",
"Frame N 132 508 455 537 510\n",
"Frame N 132 417 399 462 445\n",
"Frame N 132 705 417 732 502\n",
"Frame N 132 898 391 923 450\n",
"Frame N 132 889 339 908 394\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:21] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 133 1145 577 1191 651\n",
"Frame N 133 506 452 530 514\n",
"Frame N 133 407 457 450 518\n",
"Frame N 133 737 424 768 490\n",
"Frame N 133 969 520 1004 594\n",
"Frame N 133 844 440 863 507\n",
"Frame N 133 1053 415 1097 480\n",
"Frame N 133 419 399 465 446\n",
"Frame N 133 660 383 681 442\n",
"Frame N 133 704 418 729 507\n",
"Frame N 133 903 385 920 449\n",
"Frame N 133 888 340 907 397\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:22] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 134 1137 577 1193 650\n",
"Frame N 134 963 517 1007 595\n",
"Frame N 134 737 424 771 491\n",
"Frame N 134 505 448 527 515\n",
"Frame N 134 655 384 686 442\n",
"Frame N 134 1057 417 1096 483\n",
"Frame N 134 848 440 865 509\n",
"Frame N 134 703 419 727 506\n",
"Frame N 134 419 402 465 448\n",
"Frame N 134 403 456 439 517\n",
"Frame N 134 905 388 930 454\n",
"Frame N 134 403 456 460 517\n",
"Frame N 134 884 342 911 396\n",
"Frame N 134 1161 235 1188 281\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:22] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 135 954 519 1009 597\n",
"Frame N 135 1133 580 1191 652\n",
"Frame N 135 496 447 526 516\n",
"Frame N 135 737 426 774 493\n",
"Frame N 135 644 385 687 444\n",
"Frame N 135 852 441 870 509\n",
"Frame N 135 701 448 730 516\n",
"Frame N 135 907 389 929 456\n",
"Frame N 135 884 342 910 396\n",
"Frame N 135 420 406 465 452\n",
"Frame N 135 1062 419 1085 483\n",
"Frame N 135 406 441 438 520\n",
"Frame N 135 406 407 444 521\n",
"Frame N 135 700 417 729 515\n",
"Frame N 135 410 405 466 515\n",
"Frame N 135 702 417 719 453\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:22] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 136 946 522 1007 600\n",
"Frame N 136 1138 582 1186 657\n",
"Frame N 136 739 427 776 495\n",
"Frame N 136 491 449 523 517\n",
"Frame N 136 424 408 465 453\n",
"Frame N 136 404 454 435 520\n",
"Frame N 136 693 454 731 518\n",
"Frame N 136 641 384 684 442\n",
"Frame N 136 883 343 911 401\n",
"Frame N 136 853 441 875 511\n",
"Frame N 136 1066 420 1085 485\n",
"Frame N 136 910 390 928 451\n",
"Frame N 136 696 419 729 510\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:22] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 137 480 450 519 518\n",
"Frame N 137 944 525 1003 605\n",
"Frame N 137 684 454 731 519\n",
"Frame N 137 1144 584 1174 661\n",
"Frame N 137 402 454 431 519\n",
"Frame N 137 739 426 776 495\n",
"Frame N 137 426 409 466 453\n",
"Frame N 137 1066 422 1087 487\n",
"Frame N 137 639 383 680 443\n",
"Frame N 137 910 392 935 460\n",
"Frame N 137 888 345 912 403\n",
"Frame N 137 858 443 880 511\n",
"Frame N 137 692 420 721 463\n",
"Frame N 137 698 419 717 455\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:23] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 138 480 450 519 518\n",
"Frame N 138 944 525 1003 605\n",
"Frame N 138 684 454 731 519\n",
"Frame N 138 1144 584 1174 660\n",
"Frame N 138 402 454 431 519\n",
"Frame N 138 739 427 776 495\n",
"Frame N 138 426 409 466 453\n",
"Frame N 138 1066 422 1087 487\n",
"Frame N 138 639 383 681 443\n",
"Frame N 138 858 443 880 511\n",
"Frame N 138 888 345 913 403\n",
"Frame N 138 910 391 935 460\n",
"Frame N 138 692 420 721 464\n",
"Frame N 138 698 419 717 455\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:23] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 139 481 453 513 519\n",
"Frame N 139 1146 585 1173 663\n",
"Frame N 139 430 408 473 456\n",
"Frame N 139 1067 423 1092 490\n",
"Frame N 139 677 427 730 520\n",
"Frame N 139 401 455 429 518\n",
"Frame N 139 950 530 992 611\n",
"Frame N 139 863 445 885 512\n",
"Frame N 139 912 394 939 461\n",
"Frame N 139 640 388 673 445\n",
"Frame N 139 893 347 910 404\n",
"Frame N 139 740 428 773 495\n",
"Frame N 139 739 427 763 491\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:24] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 140 1145 585 1175 667\n",
"Frame N 140 1064 425 1098 494\n",
"Frame N 140 399 456 431 520\n",
"Frame N 140 482 457 511 521\n",
"Frame N 140 642 387 665 446\n",
"Frame N 140 913 396 942 461\n",
"Frame N 140 678 446 725 525\n",
"Frame N 140 952 533 983 613\n",
"Frame N 140 867 446 889 515\n",
"Frame N 140 895 348 911 408\n",
"Frame N 140 740 429 769 497\n",
"Frame N 140 430 408 479 458\n",
"Frame N 140 430 413 468 460\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:24] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 141 1058 427 1102 497\n",
"Frame N 141 395 459 433 522\n",
"Frame N 141 946 535 973 617\n",
"Frame N 141 1145 586 1178 666\n",
"Frame N 141 639 389 661 449\n",
"Frame N 141 477 455 512 522\n",
"Frame N 141 432 412 488 462\n",
"Frame N 141 870 449 893 518\n",
"Frame N 141 894 349 912 409\n",
"Frame N 141 910 400 947 462\n",
"Frame N 141 740 431 773 501\n",
"Frame N 141 682 457 718 526\n",
"Frame N 141 699 423 714 464\n",
"Frame N 141 684 424 717 526\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:24] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 142 1057 431 1105 500\n",
"Frame N 142 390 462 435 525\n",
"Frame N 142 1142 586 1180 664\n",
"Frame N 142 740 433 776 503\n",
"Frame N 142 941 537 978 622\n",
"Frame N 142 874 451 898 521\n",
"Frame N 142 635 390 659 449\n",
"Frame N 142 893 350 913 412\n",
"Frame N 142 472 456 501 524\n",
"Frame N 142 914 403 949 464\n",
"Frame N 142 683 424 715 531\n",
"Frame N 142 435 416 498 465\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:24] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 143 1137 588 1182 664\n",
"Frame N 143 743 435 779 504\n",
"Frame N 143 1062 435 1106 505\n",
"Frame N 143 386 464 437 526\n",
"Frame N 143 933 539 981 626\n",
"Frame N 143 626 393 657 453\n",
"Frame N 143 876 454 901 524\n",
"Frame N 143 467 462 500 525\n",
"Frame N 143 891 351 916 414\n",
"Frame N 143 916 404 947 469\n",
"Frame N 143 436 422 503 469\n",
"Frame N 143 693 422 714 486\n",
"Frame N 143 682 460 712 536\n",
"Frame N 143 684 422 714 537\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:25] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 144 1137 588 1182 664\n",
"Frame N 144 743 435 779 504\n",
"Frame N 144 1061 435 1106 505\n",
"Frame N 144 386 464 437 526\n",
"Frame N 144 933 539 981 626\n",
"Frame N 144 626 393 658 453\n",
"Frame N 144 876 454 901 524\n",
"Frame N 144 467 462 500 525\n",
"Frame N 144 891 351 916 414\n",
"Frame N 144 916 405 945 469\n",
"Frame N 144 436 422 503 469\n",
"Frame N 144 682 460 712 536\n",
"Frame N 144 693 422 714 485\n",
"Frame N 144 684 422 714 537\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:25] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 145 744 439 781 508\n",
"Frame N 145 382 468 430 520\n",
"Frame N 145 461 463 495 526\n",
"Frame N 145 920 544 981 629\n",
"Frame N 145 1135 591 1180 667\n",
"Frame N 145 1068 438 1103 508\n",
"Frame N 145 880 456 905 528\n",
"Frame N 145 616 397 655 453\n",
"Frame N 145 887 353 919 415\n",
"Frame N 145 694 423 715 487\n",
"Frame N 145 677 463 711 538\n",
"Frame N 145 919 406 944 469\n",
"Frame N 145 677 423 714 539\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:25] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 146 744 441 781 512\n",
"Frame N 146 1137 594 1179 673\n",
"Frame N 146 379 472 426 524\n",
"Frame N 146 454 466 493 528\n",
"Frame N 146 1072 440 1099 510\n",
"Frame N 146 616 399 653 455\n",
"Frame N 146 916 549 979 632\n",
"Frame N 146 884 458 908 529\n",
"Frame N 146 889 355 919 416\n",
"Frame N 146 669 457 712 541\n",
"Frame N 146 922 410 939 473\n",
"Frame N 146 694 425 714 489\n",
"Frame N 146 667 426 714 542\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:26] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 147 452 469 490 531\n",
"Frame N 147 746 443 781 514\n",
"Frame N 147 1142 597 1177 677\n",
"Frame N 147 889 459 913 530\n",
"Frame N 147 1073 443 1094 512\n",
"Frame N 147 374 473 424 527\n",
"Frame N 147 661 469 708 544\n",
"Frame N 147 614 403 652 457\n",
"Frame N 147 893 359 919 422\n",
"Frame N 147 923 411 942 478\n",
"Frame N 147 917 553 950 641\n",
"Frame N 147 918 553 972 641\n",
"Frame N 147 694 430 716 491\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:26] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 148 370 471 414 529\n",
"Frame N 148 747 445 777 517\n",
"Frame N 148 894 463 917 531\n",
"Frame N 148 453 472 488 533\n",
"Frame N 148 1141 599 1174 680\n",
"Frame N 148 1072 446 1097 515\n",
"Frame N 148 923 558 965 644\n",
"Frame N 148 619 407 652 459\n",
"Frame N 148 925 411 944 478\n",
"Frame N 148 898 360 918 423\n",
"Frame N 148 658 446 712 547\n",
"Frame N 148 692 433 715 495\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:27] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 149 897 464 921 536\n",
"Frame N 149 1140 600 1172 682\n",
"Frame N 149 1071 449 1102 520\n",
"Frame N 149 366 473 407 533\n",
"Frame N 149 923 562 955 648\n",
"Frame N 149 453 473 487 535\n",
"Frame N 149 747 447 772 520\n",
"Frame N 149 928 414 945 480\n",
"Frame N 149 619 408 653 461\n",
"Frame N 149 901 363 918 426\n",
"Frame N 149 661 476 709 549\n",
"Frame N 149 692 433 714 484\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:27] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 150 897 464 921 536\n",
"Frame N 150 1140 600 1172 682\n",
"Frame N 150 1071 449 1102 520\n",
"Frame N 150 366 473 407 533\n",
"Frame N 150 923 562 955 648\n",
"Frame N 150 747 446 772 520\n",
"Frame N 150 453 473 487 535\n",
"Frame N 150 660 476 709 550\n",
"Frame N 150 928 414 945 480\n",
"Frame N 150 619 408 653 461\n",
"Frame N 150 901 363 918 426\n",
"Frame N 150 692 432 714 484\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:27] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 151 1141 600 1177 686\n",
"Frame N 151 1069 451 1107 524\n",
"Frame N 151 746 449 774 524\n",
"Frame N 151 361 472 404 536\n",
"Frame N 151 615 408 651 462\n",
"Frame N 151 450 473 486 536\n",
"Frame N 151 902 469 927 539\n",
"Frame N 151 903 364 920 427\n",
"Frame N 151 917 565 948 650\n",
"Frame N 151 929 416 945 480\n",
"Frame N 151 665 481 697 552\n",
"Frame N 151 687 434 713 501\n",
"Frame N 151 465 438 517 481\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:28] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 152 1139 601 1182 683\n",
"Frame N 152 746 450 779 526\n",
"Frame N 152 1067 453 1111 527\n",
"Frame N 152 910 566 952 656\n",
"Frame N 152 357 470 401 535\n",
"Frame N 152 447 476 484 540\n",
"Frame N 152 614 403 651 464\n",
"Frame N 152 906 470 932 544\n",
"Frame N 152 666 487 694 556\n",
"Frame N 152 903 364 921 428\n",
"Frame N 152 690 433 714 500\n",
"Frame N 152 928 421 945 482\n",
"Frame N 152 469 441 524 484\n",
"Frame N 152 469 441 524 484\n",
"Frame N 152 932 420 947 467\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:28] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 153 1136 602 1184 682\n",
"Frame N 153 744 451 781 527\n",
"Frame N 153 902 568 953 658\n",
"Frame N 153 351 472 397 534\n",
"Frame N 153 614 404 648 466\n",
"Frame N 153 1071 456 1113 531\n",
"Frame N 153 445 477 483 542\n",
"Frame N 153 666 486 694 560\n",
"Frame N 153 899 364 924 429\n",
"Frame N 153 910 471 934 546\n",
"Frame N 153 931 423 949 480\n",
"Frame N 153 689 432 714 502\n",
"Frame N 153 477 445 526 486\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:28] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 154 1132 603 1186 681\n",
"Frame N 154 740 455 782 529\n",
"Frame N 154 342 471 393 534\n",
"Frame N 154 889 571 953 662\n",
"Frame N 154 616 403 647 467\n",
"Frame N 154 1073 459 1112 533\n",
"Frame N 154 445 479 481 543\n",
"Frame N 154 662 486 694 562\n",
"Frame N 154 914 472 937 549\n",
"Frame N 154 897 365 926 431\n",
"Frame N 154 931 426 952 485\n",
"Frame N 154 689 432 715 503\n",
"Frame N 154 482 447 534 488\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:29] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 155 740 459 781 532\n",
"Frame N 155 1131 605 1182 683\n",
"Frame N 155 617 404 645 468\n",
"Frame N 155 654 488 693 565\n",
"Frame N 155 884 576 947 665\n",
"Frame N 155 445 480 480 546\n",
"Frame N 155 1077 460 1108 536\n",
"Frame N 155 895 367 927 434\n",
"Frame N 155 916 474 940 550\n",
"Frame N 155 336 472 388 536\n",
"Frame N 155 688 433 715 504\n",
"Frame N 155 931 428 954 486\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:30] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 156 740 459 781 532\n",
"Frame N 156 1131 605 1182 683\n",
"Frame N 156 617 404 645 468\n",
"Frame N 156 884 576 947 665\n",
"Frame N 156 654 488 693 565\n",
"Frame N 156 445 480 480 545\n",
"Frame N 156 1077 460 1107 536\n",
"Frame N 156 895 367 927 434\n",
"Frame N 156 336 472 388 536\n",
"Frame N 156 916 474 940 550\n",
"Frame N 156 688 433 715 505\n",
"Frame N 156 931 428 954 486\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:30] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 157 886 579 939 671\n",
"Frame N 157 744 461 779 533\n",
"Frame N 157 647 490 691 566\n",
"Frame N 157 617 405 643 470\n",
"Frame N 157 1137 609 1177 689\n",
"Frame N 157 332 474 382 542\n",
"Frame N 157 443 481 476 547\n",
"Frame N 157 917 474 945 551\n",
"Frame N 157 898 369 927 436\n",
"Frame N 157 1080 461 1102 539\n",
"Frame N 157 688 434 715 505\n",
"Frame N 157 933 429 955 487\n",
"Frame N 157 686 445 713 508\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:30] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 158 647 492 689 568\n",
"Frame N 158 744 462 774 534\n",
"Frame N 158 439 481 473 547\n",
"Frame N 158 615 404 642 467\n",
"Frame N 158 889 584 927 672\n",
"Frame N 158 1139 610 1170 692\n",
"Frame N 158 920 476 947 551\n",
"Frame N 158 1081 462 1103 540\n",
"Frame N 158 686 436 716 507\n",
"Frame N 158 901 372 926 438\n",
"Frame N 158 329 478 353 544\n",
"Frame N 158 329 477 371 543\n",
"Frame N 158 931 429 961 493\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:30] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 159 649 495 688 572\n",
"Frame N 159 434 482 472 547\n",
"Frame N 159 614 404 641 467\n",
"Frame N 159 743 462 769 537\n",
"Frame N 159 1082 464 1105 541\n",
"Frame N 159 884 585 913 674\n",
"Frame N 159 688 438 717 508\n",
"Frame N 159 1137 609 1169 694\n",
"Frame N 159 903 373 927 439\n",
"Frame N 159 923 477 950 554\n",
"Frame N 159 323 477 356 546\n",
"Frame N 159 932 431 955 490\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:31] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 160 430 481 470 550\n",
"Frame N 160 652 498 684 573\n",
"Frame N 160 878 585 912 678\n",
"Frame N 160 1078 465 1107 542\n",
"Frame N 160 317 480 354 549\n",
"Frame N 160 611 404 639 469\n",
"Frame N 160 905 374 927 439\n",
"Frame N 160 1132 608 1169 697\n",
"Frame N 160 739 465 766 540\n",
"Frame N 160 689 440 716 511\n",
"Frame N 160 928 486 956 557\n",
"Frame N 160 491 472 549 503\n",
"Frame N 160 932 434 950 488\n",
"Frame N 160 930 434 955 491\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:31] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 161 868 587 913 680\n",
"Frame N 161 651 501 680 577\n",
"Frame N 161 738 465 767 544\n",
"Frame N 161 426 487 466 552\n",
"Frame N 161 1135 608 1173 699\n",
"Frame N 161 906 373 928 440\n",
"Frame N 161 1077 467 1108 543\n",
"Frame N 161 607 404 639 469\n",
"Frame N 161 929 488 959 560\n",
"Frame N 161 313 481 349 548\n",
"Frame N 161 690 443 716 514\n",
"Frame N 161 933 436 952 489\n",
"Frame N 161 492 481 552 503\n",
"Frame N 161 932 435 959 491\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:31] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 162 868 587 913 680\n",
"Frame N 162 651 501 680 577\n",
"Frame N 162 426 487 466 552\n",
"Frame N 162 738 465 767 544\n",
"Frame N 162 1135 608 1173 699\n",
"Frame N 162 906 373 928 439\n",
"Frame N 162 607 404 639 469\n",
"Frame N 162 1077 467 1108 543\n",
"Frame N 162 928 487 960 560\n",
"Frame N 162 313 482 349 548\n",
"Frame N 162 690 443 717 514\n",
"Frame N 162 933 436 952 489\n",
"Frame N 162 492 481 552 503\n",
"Frame N 162 932 435 959 491\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:31] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 163 853 589 912 683\n",
"Frame N 163 307 476 341 551\n",
"Frame N 163 1135 609 1180 696\n",
"Frame N 163 425 492 463 555\n",
"Frame N 163 649 505 678 581\n",
"Frame N 163 932 492 966 562\n",
"Frame N 163 737 466 770 545\n",
"Frame N 163 1077 468 1109 547\n",
"Frame N 163 902 373 929 442\n",
"Frame N 163 606 405 639 469\n",
"Frame N 163 690 445 717 514\n",
"Frame N 163 495 484 555 507\n",
"Frame N 163 933 437 951 495\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:32] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 164 846 594 911 686\n",
"Frame N 164 734 467 774 548\n",
"Frame N 164 933 492 971 566\n",
"Frame N 164 648 503 676 581\n",
"Frame N 164 1135 610 1174 694\n",
"Frame N 164 422 494 463 556\n",
"Frame N 164 300 474 340 550\n",
"Frame N 164 1084 473 1109 550\n",
"Frame N 164 902 374 932 443\n",
"Frame N 164 607 410 640 470\n",
"Frame N 164 497 484 561 514\n",
"Frame N 164 925 440 951 491\n",
"Frame N 164 689 458 719 516\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:32] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 165 730 469 776 549\n",
"Frame N 165 845 597 907 691\n",
"Frame N 165 935 497 978 567\n",
"Frame N 165 287 478 335 550\n",
"Frame N 165 643 504 676 584\n",
"Frame N 165 423 498 462 557\n",
"Frame N 165 1135 612 1175 693\n",
"Frame N 165 1087 475 1110 551\n",
"Frame N 165 905 376 934 443\n",
"Frame N 165 608 413 641 471\n",
"Frame N 165 931 443 952 499\n",
"Frame N 165 508 487 566 516\n",
"Frame N 165 690 468 718 518\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:32] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 166 731 472 778 552\n",
"Frame N 166 639 503 678 586\n",
"Frame N 166 1137 616 1176 697\n",
"Frame N 166 284 478 332 550\n",
"Frame N 166 936 497 984 569\n",
"Frame N 166 849 601 898 694\n",
"Frame N 166 611 414 643 472\n",
"Frame N 166 1089 478 1110 554\n",
"Frame N 166 426 500 463 558\n",
"Frame N 166 909 378 936 445\n",
"Frame N 166 513 488 568 517\n",
"Frame N 166 929 444 954 508\n",
"Frame N 166 928 441 963 510\n",
"Frame N 166 692 464 722 520\n",
"Frame N 166 700 451 723 483\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:32] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 167 636 505 679 588\n",
"Frame N 167 736 474 781 554\n",
"Frame N 167 934 504 987 570\n",
"Frame N 167 283 483 327 554\n",
"Frame N 167 852 602 887 696\n",
"Frame N 167 616 414 644 473\n",
"Frame N 167 1089 479 1114 557\n",
"Frame N 167 1141 618 1176 699\n",
"Frame N 167 431 491 464 558\n",
"Frame N 167 914 379 940 448\n",
"Frame N 167 698 452 726 518\n",
"Frame N 167 517 490 574 518\n",
"Frame N 167 928 443 969 513\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:33] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 168 635 505 679 589\n",
"Frame N 168 736 474 781 554\n",
"Frame N 168 934 505 987 570\n",
"Frame N 168 283 483 327 554\n",
"Frame N 168 852 602 887 696\n",
"Frame N 168 616 414 644 473\n",
"Frame N 168 1089 479 1114 558\n",
"Frame N 168 1141 618 1176 699\n",
"Frame N 168 431 491 464 558\n",
"Frame N 168 914 379 940 448\n",
"Frame N 168 698 452 726 518\n",
"Frame N 168 517 490 574 518\n",
"Frame N 168 928 443 969 513\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:33] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 169 739 475 781 556\n",
"Frame N 169 640 509 682 592\n",
"Frame N 169 280 485 323 557\n",
"Frame N 169 1090 480 1121 559\n",
"Frame N 169 436 490 466 561\n",
"Frame N 169 1141 617 1175 702\n",
"Frame N 169 848 603 875 699\n",
"Frame N 169 617 414 646 476\n",
"Frame N 169 931 507 988 570\n",
"Frame N 169 699 454 731 520\n",
"Frame N 169 919 380 942 448\n",
"Frame N 169 524 491 577 520\n",
"Frame N 169 925 445 953 515\n",
"Frame N 169 925 444 969 514\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:33] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 170 743 477 779 557\n",
"Frame N 170 842 604 880 703\n",
"Frame N 170 1142 617 1174 704\n",
"Frame N 170 1091 481 1127 564\n",
"Frame N 170 645 512 683 592\n",
"Frame N 170 441 491 467 562\n",
"Frame N 170 279 490 314 559\n",
"Frame N 170 924 382 947 448\n",
"Frame N 170 701 457 735 521\n",
"Frame N 170 622 412 651 475\n",
"Frame N 170 934 513 989 572\n",
"Frame N 170 528 493 584 522\n",
"Frame N 170 925 444 954 516\n",
"Frame N 170 130 434 156 489\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:33] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 171 836 606 882 704\n",
"Frame N 171 1093 481 1132 565\n",
"Frame N 171 1144 615 1177 705\n",
"Frame N 171 650 516 684 595\n",
"Frame N 171 747 477 780 561\n",
"Frame N 171 445 492 471 563\n",
"Frame N 171 277 490 303 560\n",
"Frame N 171 625 414 655 476\n",
"Frame N 171 705 452 739 523\n",
"Frame N 171 927 382 951 446\n",
"Frame N 171 941 509 987 575\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:34] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 172 832 607 883 705\n",
"Frame N 172 1146 614 1184 706\n",
"Frame N 172 1096 484 1137 568\n",
"Frame N 172 653 517 686 596\n",
"Frame N 172 629 414 659 477\n",
"Frame N 172 711 453 743 524\n",
"Frame N 172 751 477 784 562\n",
"Frame N 172 450 493 475 565\n",
"Frame N 172 273 489 302 562\n",
"Frame N 172 931 384 956 446\n",
"Frame N 172 924 501 982 576\n",
"Frame N 172 939 458 959 518\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:34] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 173 828 610 881 706\n",
"Frame N 173 1148 615 1191 703\n",
"Frame N 173 632 415 662 478\n",
"Frame N 173 1101 487 1140 571\n",
"Frame N 173 658 516 689 599\n",
"Frame N 173 455 491 479 567\n",
"Frame N 173 716 456 748 526\n",
"Frame N 173 271 487 301 559\n",
"Frame N 173 755 477 787 562\n",
"Frame N 173 937 387 961 450\n",
"Frame N 173 939 456 961 520\n",
"Frame N 173 550 500 597 528\n",
"Frame N 173 925 511 987 577\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:35] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 174 828 610 881 706\n",
"Frame N 174 1148 615 1191 703\n",
"Frame N 174 632 415 662 478\n",
"Frame N 174 1101 487 1140 571\n",
"Frame N 174 658 516 689 599\n",
"Frame N 174 455 491 479 567\n",
"Frame N 174 716 456 749 526\n",
"Frame N 174 271 487 301 559\n",
"Frame N 174 755 477 787 562\n",
"Frame N 174 937 387 961 450\n",
"Frame N 174 939 456 961 520\n",
"Frame N 174 550 499 598 528\n",
"Frame N 174 924 509 987 577\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:35] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 175 1145 617 1195 702\n",
"Frame N 175 662 513 693 600\n",
"Frame N 175 759 477 788 562\n",
"Frame N 175 268 487 301 560\n",
"Frame N 175 1105 491 1140 572\n",
"Frame N 175 832 613 873 708\n",
"Frame N 175 460 489 483 569\n",
"Frame N 175 942 387 968 452\n",
"Frame N 175 638 414 667 478\n",
"Frame N 175 722 456 752 528\n",
"Frame N 175 559 500 604 531\n",
"Frame N 175 929 456 993 581\n",
"Frame N 175 265 407 289 467\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:35] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 176 1144 618 1202 702\n",
"Frame N 176 760 480 792 564\n",
"Frame N 176 666 516 697 602\n",
"Frame N 176 262 489 302 563\n",
"Frame N 176 464 492 487 572\n",
"Frame N 176 643 418 672 479\n",
"Frame N 176 730 457 759 531\n",
"Frame N 176 832 615 866 710\n",
"Frame N 176 947 387 975 452\n",
"Frame N 176 1110 495 1140 575\n",
"Frame N 176 942 462 966 515\n",
"Frame N 176 565 503 609 535\n",
"Frame N 176 943 508 997 579\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:35] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 177 253 492 301 566\n",
"Frame N 177 1148 621 1205 703\n",
"Frame N 177 649 412 678 482\n",
"Frame N 177 666 516 703 603\n",
"Frame N 177 762 483 796 566\n",
"Frame N 177 833 616 864 712\n",
"Frame N 177 471 495 493 573\n",
"Frame N 177 953 389 980 452\n",
"Frame N 177 1112 498 1142 578\n",
"Frame N 177 940 515 1000 582\n",
"Frame N 177 943 462 969 518\n",
"Frame N 177 735 462 764 533\n",
"Frame N 177 569 504 615 536\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:36] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 178 251 493 299 569\n",
"Frame N 178 1155 624 1203 707\n",
"Frame N 178 667 520 708 606\n",
"Frame N 178 1111 499 1148 577\n",
"Frame N 178 828 616 865 716\n",
"Frame N 178 766 486 800 569\n",
"Frame N 178 958 388 985 456\n",
"Frame N 178 475 497 500 575\n",
"Frame N 178 655 413 683 483\n",
"Frame N 178 943 516 1001 585\n",
"Frame N 178 740 462 769 533\n",
"Frame N 178 946 464 969 519\n",
"Frame N 178 575 505 622 537\n",
"Frame N 178 52 463 75 526\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:36] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 179 673 521 711 609\n",
"Frame N 179 820 616 866 718\n",
"Frame N 179 1160 625 1202 710\n",
"Frame N 179 253 496 297 574\n",
"Frame N 179 1114 499 1156 581\n",
"Frame N 179 480 499 504 576\n",
"Frame N 179 771 489 803 572\n",
"Frame N 179 963 389 992 460\n",
"Frame N 179 747 460 776 535\n",
"Frame N 179 660 415 689 484\n",
"Frame N 179 578 505 627 538\n",
"Frame N 179 947 471 971 525\n",
"Frame N 179 948 522 997 589\n",
"Frame N 179 948 522 978 589\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:36] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 180 673 521 711 609\n",
"Frame N 180 820 616 866 718\n",
"Frame N 180 1160 625 1202 710\n",
"Frame N 180 253 496 297 574\n",
"Frame N 180 1114 499 1156 581\n",
"Frame N 180 480 499 504 576\n",
"Frame N 180 771 489 803 572\n",
"Frame N 180 963 389 992 460\n",
"Frame N 180 747 460 776 535\n",
"Frame N 180 660 414 689 484\n",
"Frame N 180 578 505 627 538\n",
"Frame N 180 947 471 972 524\n",
"Frame N 180 948 521 997 589\n",
"Frame N 180 948 522 974 589\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:36] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 181 812 619 868 719\n",
"Frame N 181 679 523 716 610\n",
"Frame N 181 1165 626 1202 714\n",
"Frame N 181 1118 501 1163 583\n",
"Frame N 181 971 389 998 461\n",
"Frame N 181 668 413 695 487\n",
"Frame N 181 486 499 512 579\n",
"Frame N 181 776 492 807 575\n",
"Frame N 181 754 462 783 538\n",
"Frame N 181 257 498 291 573\n",
"Frame N 181 948 473 982 593\n",
"Frame N 181 582 506 633 539\n",
"Frame N 181 949 474 973 586\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:37] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 182 810 622 866 720\n",
"Frame N 182 1120 504 1169 586\n",
"Frame N 182 683 526 722 611\n",
"Frame N 182 491 499 518 581\n",
"Frame N 182 1169 625 1202 715\n",
"Frame N 182 978 391 1004 463\n",
"Frame N 182 783 490 811 576\n",
"Frame N 182 673 414 702 490\n",
"Frame N 182 949 476 977 593\n",
"Frame N 182 760 463 789 539\n",
"Frame N 182 589 506 640 542\n",
"Frame N 182 258 499 288 577\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:37] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 183 688 528 724 613\n",
"Frame N 183 1125 505 1174 591\n",
"Frame N 183 1173 625 1206 716\n",
"Frame N 183 814 626 863 720\n",
"Frame N 183 786 491 817 579\n",
"Frame N 183 984 392 1011 465\n",
"Frame N 183 682 412 707 490\n",
"Frame N 183 498 500 525 584\n",
"Frame N 183 949 478 984 594\n",
"Frame N 183 594 508 647 542\n",
"Frame N 183 255 492 283 576\n",
"Frame N 183 767 461 796 540\n",
"Frame N 183 950 478 977 565\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:37] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 184 694 529 728 615\n",
"Frame N 184 791 493 822 579\n",
"Frame N 184 824 629 862 719\n",
"Frame N 184 1129 509 1181 595\n",
"Frame N 184 1176 625 1209 717\n",
"Frame N 184 947 523 989 597\n",
"Frame N 184 990 394 1018 466\n",
"Frame N 184 504 505 530 585\n",
"Frame N 184 689 421 715 492\n",
"Frame N 184 254 492 287 579\n",
"Frame N 184 599 509 653 544\n",
"Frame N 184 955 478 984 545\n",
"Frame N 184 773 469 802 544\n",
"Frame N 184 77 470 99 535\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:38] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 185 1180 625 1214 718\n",
"Frame N 185 824 632 862 720\n",
"Frame N 185 701 530 735 618\n",
"Frame N 185 797 500 827 582\n",
"Frame N 185 509 505 538 589\n",
"Frame N 185 697 422 723 492\n",
"Frame N 185 946 530 991 605\n",
"Frame N 185 253 500 288 583\n",
"Frame N 185 996 396 1025 468\n",
"Frame N 185 780 472 811 548\n",
"Frame N 185 1132 513 1178 598\n",
"Frame N 185 956 480 991 547\n",
"Frame N 185 609 512 660 546\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:38] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 186 1180 625 1214 718\n",
"Frame N 186 824 632 862 720\n",
"Frame N 186 701 530 735 618\n",
"Frame N 186 797 501 827 582\n",
"Frame N 186 509 505 538 589\n",
"Frame N 186 696 422 723 492\n",
"Frame N 186 253 500 288 583\n",
"Frame N 186 996 396 1025 468\n",
"Frame N 186 946 530 991 605\n",
"Frame N 186 780 472 811 548\n",
"Frame N 186 1131 513 1177 598\n",
"Frame N 186 956 480 991 548\n",
"Frame N 186 609 511 660 546\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:38] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 187 822 633 862 720\n",
"Frame N 187 1183 628 1219 717\n",
"Frame N 187 515 506 545 591\n",
"Frame N 187 706 530 740 619\n",
"Frame N 187 1004 398 1032 469\n",
"Frame N 187 798 503 831 584\n",
"Frame N 187 250 507 290 584\n",
"Frame N 187 703 422 729 494\n",
"Frame N 187 1139 517 1182 600\n",
"Frame N 187 958 482 997 548\n",
"Frame N 187 946 535 994 609\n",
"Frame N 187 612 514 667 548\n",
"Frame N 187 788 471 817 552\n",
"Frame N 187 790 471 820 584\n",
"Frame N 187 11 499 39 553\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:39] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 188 799 500 837 586\n",
"Frame N 188 821 633 864 719\n",
"Frame N 188 1184 632 1223 718\n",
"Frame N 188 712 532 744 622\n",
"Frame N 188 522 507 551 593\n",
"Frame N 188 246 508 290 585\n",
"Frame N 188 711 423 737 498\n",
"Frame N 188 947 539 993 614\n",
"Frame N 188 1138 519 1178 603\n",
"Frame N 188 1012 401 1039 471\n",
"Frame N 188 796 473 824 552\n",
"Frame N 188 964 485 996 543\n",
"Frame N 188 16 503 45 555\n",
"Frame N 188 619 516 672 552\n",
"Frame N 188 93 474 116 542\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:39] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 189 820 635 865 720\n",
"Frame N 189 804 502 843 589\n",
"Frame N 189 530 511 559 596\n",
"Frame N 189 244 514 288 588\n",
"Frame N 189 719 422 744 499\n",
"Frame N 189 1140 521 1184 606\n",
"Frame N 189 1189 635 1226 719\n",
"Frame N 189 1020 402 1045 475\n",
"Frame N 189 716 535 752 626\n",
"Frame N 189 966 488 997 546\n",
"Frame N 189 948 548 985 616\n",
"Frame N 189 627 518 680 553\n",
"Frame N 189 803 474 834 555\n",
"Frame N 189 802 478 836 582\n",
"Frame N 189 99 478 124 543\n",
"Frame N 189 21 505 50 557\n",
"Frame N 189 209 460 236 515\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:39] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 190 1143 522 1189 609\n",
"Frame N 190 820 638 866 720\n",
"Frame N 190 536 514 565 599\n",
"Frame N 190 1027 405 1051 476\n",
"Frame N 190 726 424 753 500\n",
"Frame N 190 248 518 285 590\n",
"Frame N 190 1198 639 1231 720\n",
"Frame N 190 810 478 849 591\n",
"Frame N 190 969 494 998 563\n",
"Frame N 190 720 537 757 628\n",
"Frame N 190 946 550 979 620\n",
"Frame N 190 635 521 687 555\n",
"Frame N 190 104 480 129 546\n",
"Frame N 190 28 507 57 558\n",
"Frame N 190 214 465 243 517\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:39] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 191 1147 524 1196 613\n",
"Frame N 191 727 538 763 631\n",
"Frame N 191 816 481 856 594\n",
"Frame N 191 971 495 1000 569\n",
"Frame N 191 1036 407 1058 477\n",
"Frame N 191 822 642 867 720\n",
"Frame N 191 947 552 982 623\n",
"Frame N 191 544 513 573 600\n",
"Frame N 191 1202 639 1236 719\n",
"Frame N 191 250 521 283 594\n",
"Frame N 191 734 424 763 500\n",
"Frame N 191 641 522 695 559\n",
"Frame N 191 33 509 63 561\n",
"Frame N 191 110 481 133 549\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:40] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 192 1147 524 1196 613\n",
"Frame N 192 727 538 763 631\n",
"Frame N 192 816 481 856 594\n",
"Frame N 192 971 495 1000 569\n",
"Frame N 192 1036 407 1058 477\n",
"Frame N 192 822 642 867 720\n",
"Frame N 192 946 552 982 623\n",
"Frame N 192 544 513 573 600\n",
"Frame N 192 1201 639 1236 719\n",
"Frame N 192 250 520 283 593\n",
"Frame N 192 734 424 763 500\n",
"Frame N 192 641 522 695 559\n",
"Frame N 192 33 509 62 561\n",
"Frame N 192 111 481 133 549\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:40] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 193 1152 528 1202 618\n",
"Frame N 193 946 553 988 625\n",
"Frame N 193 825 499 863 597\n",
"Frame N 193 974 500 1003 572\n",
"Frame N 193 735 540 770 633\n",
"Frame N 193 1043 409 1066 482\n",
"Frame N 193 826 645 868 720\n",
"Frame N 193 741 428 769 503\n",
"Frame N 193 551 519 579 604\n",
"Frame N 193 1206 639 1240 720\n",
"Frame N 193 38 511 67 562\n",
"Frame N 193 651 523 701 562\n",
"Frame N 193 116 482 141 549\n",
"Frame N 193 253 521 282 595\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:41] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 194 945 555 992 628\n",
"Frame N 194 832 495 870 599\n",
"Frame N 194 1156 531 1204 622\n",
"Frame N 194 976 502 1009 577\n",
"Frame N 194 742 542 776 636\n",
"Frame N 194 558 520 585 607\n",
"Frame N 194 1211 638 1244 720\n",
"Frame N 194 829 648 870 720\n",
"Frame N 194 1051 411 1074 483\n",
"Frame N 194 750 433 777 505\n",
"Frame N 194 654 525 709 565\n",
"Frame N 194 45 513 73 563\n",
"Frame N 194 252 522 282 600\n",
"Frame N 194 231 472 260 525\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:41] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 195 941 556 995 635\n",
"Frame N 195 564 521 593 609\n",
"Frame N 195 839 490 873 601\n",
"Frame N 195 750 545 782 637\n",
"Frame N 195 1159 534 1208 624\n",
"Frame N 195 977 505 1013 583\n",
"Frame N 195 757 438 783 506\n",
"Frame N 195 1057 411 1081 483\n",
"Frame N 195 833 650 873 719\n",
"Frame N 195 1217 639 1249 720\n",
"Frame N 195 248 522 283 602\n",
"Frame N 195 51 515 79 567\n",
"Frame N 195 662 528 716 568\n",
"Frame N 195 128 487 152 555\n",
"Frame N 195 237 474 266 526\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:41] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 196 571 522 600 610\n",
"Frame N 196 848 497 880 604\n",
"Frame N 196 757 546 788 639\n",
"Frame N 196 245 522 286 605\n",
"Frame N 196 941 559 995 641\n",
"Frame N 196 979 509 1013 584\n",
"Frame N 196 765 439 792 509\n",
"Frame N 196 1065 413 1089 484\n",
"Frame N 196 1222 639 1255 720\n",
"Frame N 196 1164 538 1207 628\n",
"Frame N 196 835 651 876 719\n",
"Frame N 196 56 516 85 568\n",
"Frame N 196 674 530 721 570\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:42] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 197 764 547 795 641\n",
"Frame N 197 578 526 607 612\n",
"Frame N 197 244 530 292 608\n",
"Frame N 197 943 562 994 646\n",
"Frame N 197 982 512 1016 591\n",
"Frame N 197 855 492 886 606\n",
"Frame N 197 1164 541 1205 629\n",
"Frame N 197 1073 414 1094 485\n",
"Frame N 197 772 441 799 509\n",
"Frame N 197 836 655 880 719\n",
"Frame N 197 675 532 729 572\n",
"Frame N 197 1228 641 1263 720\n",
"Frame N 197 62 518 91 570\n",
"Frame N 197 139 489 163 557\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:42] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 198 764 547 795 641\n",
"Frame N 198 578 526 607 612\n",
"Frame N 198 244 530 292 608\n",
"Frame N 198 943 562 994 646\n",
"Frame N 198 982 512 1016 591\n",
"Frame N 198 855 492 886 606\n",
"Frame N 198 1164 541 1205 629\n",
"Frame N 198 1073 414 1095 485\n",
"Frame N 198 772 441 799 510\n",
"Frame N 198 836 656 880 719\n",
"Frame N 198 675 532 729 572\n",
"Frame N 198 1228 641 1263 720\n",
"Frame N 198 62 518 91 570\n",
"Frame N 198 138 489 163 557\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:42] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 199 0 67 579 712\n",
"Frame N 199 66 475 261 716\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:43] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 200 1 68 580 710\n",
"Frame N 200 -4 4 1253 712\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:43] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 201 -1 66 645 711\n",
"Frame N 201 0 7 1236 712\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:43] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 202 0 80 706 711\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:44] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 203 0 124 743 710\n",
"Frame N 203 12 0 1253 711\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:44] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 204 0 124 742 710\n",
"Frame N 204 11 -1 1251 711\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:45] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 205 32 145 776 712\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:45] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 206 2 156 794 710\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:45] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 207 5 147 804 712\n",
"Frame N 207 785 72 1279 709\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:46] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 208 47 136 807 711\n",
"Frame N 208 881 93 1281 709\n",
"Frame N 209 111 130 806 712\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:46] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 209 977 105 1281 709\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:46] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 210 111 130 807 712\n",
"Frame N 210 977 104 1281 709\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:46] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 211 136 126 804 712\n",
"Frame N 211 1 3 1248 712\n",
"Frame N 211 985 188 1283 711\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:46] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 212 158 138 802 712\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:47] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 213 176 168 811 712\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:47] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 214 255 196 832 712\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:47] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 215 263 216 838 712\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:47] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 216 263 216 837 712\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:48] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 217 292 219 825 712\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:48] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 218 328 208 822 713\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:48] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 219 369 194 828 712\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:48] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 220 404 170 847 712\n",
"Frame N 220 -3 -2 1283 713\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:49] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 221 428 152 876 714\n",
"Frame N 221 0 9 1271 715\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:49] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 222 428 152 876 714\n",
"Frame N 222 0 10 1276 715\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:49] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 223 453 152 913 713\n",
"Frame N 223 -2 7 1273 715\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:49] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 224 474 160 958 712\n",
"Frame N 225 481 157 987 713\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:50] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 225 0 343 102 458\n",
"Frame N 225 0 343 102 461\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:50] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 226 481 176 998 712\n",
"Frame N 226 0 314 189 448\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:50] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 227 473 174 1028 712\n",
"Frame N 227 1 286 271 434\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:50] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 228 471 174 1028 712\n",
"Frame N 228 1 286 271 435\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:50] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 229 460 153 1041 712\n",
"Frame N 229 64 263 347 415\n",
"Frame N 229 -4 3 1274 714\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:51] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 230 406 121 1053 712\n",
"Frame N 230 142 238 421 387\n",
"Frame N 230 3 111 1276 711\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:51] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 231 435 92 1074 712\n",
"Frame N 231 214 210 491 359\n",
"Frame N 231 -1 17 1275 723\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:51] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 232 447 72 1101 711\n",
"Frame N 232 285 183 559 331\n",
"Frame N 232 271 340 483 706\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:51] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 233 212 63 1108 712\n",
"Frame N 233 352 158 621 308\n",
"Frame N 233 0 10 1278 452\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:52] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 234 212 64 1108 712\n",
"Frame N 234 353 158 622 308\n",
"Frame N 234 0 10 1277 451\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:52] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 235 122 75 1107 713\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:52] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 236 107 95 1097 712\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:53] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 237 72 112 1068 714\n",
"Frame N 237 46 67 415 359\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:53] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 238 56 127 1031 714\n",
"Frame N 238 746 93 896 191\n",
"Frame N 238 117 65 483 340\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:53] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 239 64 127 979 714\n",
"Frame N 239 189 75 549 339\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:53] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 240 64 127 980 714\n",
"Frame N 240 190 75 548 337\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:53] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 241 86 120 971 715\n",
"Frame N 241 775 85 1033 226\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:54] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 242 114 107 970 714\n",
"Frame N 242 835 84 1106 225\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:54] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 243 148 98 949 714\n",
"Frame N 243 910 78 1180 216\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:54] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 244 160 104 960 715\n",
"Frame N 244 983 66 1253 205\n",
"Frame N 244 -1 2 1276 708\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:54] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 245 183 103 972 713\n",
"Frame N 245 21 0 1280 710\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:55] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 246 183 102 972 713\n",
"Frame N 246 21 0 1280 710\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:55] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 247 172 151 1002 713\n",
"Frame N 247 11 1 1281 713\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:55] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 248 209 167 1028 713\n",
"Frame N 248 -1 4 1275 650\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:55] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 249 294 158 1062 713\n",
"Frame N 249 -3 -1 1266 711\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:56] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 250 314 177 1093 713\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:56] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 251 321 172 1114 712\n",
"Frame N 251 90 61 403 433\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:56] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 252 321 172 1114 712\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:57] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 253 319 147 1128 713\n",
"Frame N 253 -3 -5 1282 715\n",
"Frame N 253 153 55 467 416\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:57] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 254 321 133 1129 714\n",
"Frame N 254 0 0 1267 715\n",
"Frame N 254 242 69 527 376\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:58] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 255 216 1 435 351\n",
"Frame N 255 588 1 950 485\n",
"Frame N 255 334 427 428 513\n",
"Frame N 255 16 26 139 220\n",
"Frame N 255 1027 0 1159 217\n",
"Frame N 255 1129 2 1227 221\n",
"Frame N 255 125 150 235 223\n",
"Frame N 255 678 296 738 339\n",
"Frame N 255 907 0 1008 218\n",
"Frame N 255 886 63 974 217\n",
"Frame N 255 891 133 974 219\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:58] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 256 196 1 417 350\n",
"Frame N 256 585 2 938 490\n",
"Frame N 256 333 427 427 514\n",
"Frame N 256 2 21 118 219\n",
"Frame N 256 1117 1 1217 218\n",
"Frame N 256 130 149 215 221\n",
"Frame N 256 882 61 962 218\n",
"Frame N 256 1018 0 1149 211\n",
"Frame N 256 663 295 724 340\n",
"Frame N 256 554 118 653 219\n",
"Frame N 256 892 0 996 219\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:59] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 257 179 2 398 348\n",
"Frame N 257 578 2 926 497\n",
"Frame N 257 330 428 427 515\n",
"Frame N 257 0 17 99 217\n",
"Frame N 257 1109 2 1208 217\n",
"Frame N 257 1005 0 1141 214\n",
"Frame N 257 538 115 638 218\n",
"Frame N 257 110 147 195 219\n",
"Frame N 257 648 294 709 339\n",
"Frame N 257 878 95 950 218\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:59] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 258 179 2 398 348\n",
"Frame N 258 579 2 926 497\n",
"Frame N 258 330 428 427 516\n",
"Frame N 258 0 17 99 217\n",
"Frame N 258 1109 2 1208 217\n",
"Frame N 258 1005 0 1141 213\n",
"Frame N 258 538 115 638 218\n",
"Frame N 258 110 147 195 219\n",
"Frame N 258 878 127 950 218\n",
"Frame N 258 648 294 709 339\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:50:59] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 259 160 1 381 349\n",
"Frame N 259 566 2 919 505\n",
"Frame N 259 329 428 426 517\n",
"Frame N 259 0 13 84 215\n",
"Frame N 259 1006 0 1128 209\n",
"Frame N 259 1093 2 1198 216\n",
"Frame N 259 94 145 175 216\n",
"Frame N 259 523 112 628 217\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:00] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 260 142 2 362 348\n",
"Frame N 260 567 1 904 512\n",
"Frame N 260 328 428 424 517\n",
"Frame N 260 -1 14 57 212\n",
"Frame N 260 507 110 613 214\n",
"Frame N 260 1011 0 1118 209\n",
"Frame N 260 46 141 159 215\n",
"Frame N 260 1084 5 1189 211\n",
"Frame N 260 620 292 681 337\n",
"Frame N 260 868 121 926 215\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:00] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 261 125 1 344 348\n",
"Frame N 261 328 427 424 519\n",
"Frame N 261 513 2 894 520\n",
"Frame N 261 1075 1 1180 210\n",
"Frame N 261 490 107 597 213\n",
"Frame N 261 51 140 138 213\n",
"Frame N 261 1004 0 1108 208\n",
"Frame N 261 0 66 39 211\n",
"Frame N 261 603 291 666 338\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:00] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 262 103 1 326 349\n",
"Frame N 262 326 427 425 521\n",
"Frame N 262 554 2 891 524\n",
"Frame N 262 475 105 564 211\n",
"Frame N 262 1062 1 1170 209\n",
"Frame N 262 24 138 119 211\n",
"Frame N 262 987 1 1099 205\n",
"Frame N 262 588 291 652 338\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:01] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 263 84 1 307 347\n",
"Frame N 263 326 427 425 523\n",
"Frame N 263 553 1 874 524\n",
"Frame N 263 1057 1 1163 208\n",
"Frame N 263 459 101 556 209\n",
"Frame N 263 990 0 1088 206\n",
"Frame N 263 3 136 97 209\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:01] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 264 84 1 307 347\n",
"Frame N 264 326 427 425 523\n",
"Frame N 264 553 1 873 524\n",
"Frame N 264 1057 1 1163 208\n",
"Frame N 264 458 101 556 209\n",
"Frame N 264 990 0 1088 206\n",
"Frame N 264 5 135 98 210\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:01] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 265 64 2 290 348\n",
"Frame N 265 325 428 426 525\n",
"Frame N 265 1045 0 1152 207\n",
"Frame N 265 547 1 869 527\n",
"Frame N 265 443 98 552 207\n",
"Frame N 265 0 134 77 208\n",
"Frame N 265 977 0 1080 197\n",
"Frame N 265 558 289 623 338\n",
"Frame N 265 850 1 917 209\n",
"Frame N 265 1005 119 1060 207\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:01] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 266 47 1 270 348\n",
"Frame N 266 324 428 427 526\n",
"Frame N 266 536 1 864 529\n",
"Frame N 266 427 96 537 205\n",
"Frame N 266 1034 1 1143 206\n",
"Frame N 266 964 0 1068 200\n",
"Frame N 266 0 132 57 206\n",
"Frame N 266 543 289 608 337\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:02] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 267 27 1 252 348\n",
"Frame N 267 325 428 428 528\n",
"Frame N 267 409 94 523 205\n",
"Frame N 267 525 1 865 534\n",
"Frame N 267 1027 1 1133 204\n",
"Frame N 267 955 0 1060 201\n",
"Frame N 267 529 288 593 338\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:02] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 268 9 1 233 348\n",
"Frame N 268 326 429 430 530\n",
"Frame N 268 393 91 506 203\n",
"Frame N 268 1020 0 1125 201\n",
"Frame N 268 512 1 895 535\n",
"Frame N 268 506 0 627 194\n",
"Frame N 268 946 0 1050 197\n",
"Frame N 268 513 288 579 337\n",
"Frame N 268 975 113 1028 203\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:02] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 269 0 1 215 348\n",
"Frame N 269 327 430 431 532\n",
"Frame N 269 378 89 491 202\n",
"Frame N 269 497 0 895 538\n",
"Frame N 269 1004 1 1116 201\n",
"Frame N 269 938 0 1039 200\n",
"Frame N 269 491 0 613 193\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:03] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 270 0 1 215 349\n",
"Frame N 270 327 430 431 532\n",
"Frame N 270 378 89 491 202\n",
"Frame N 270 497 0 890 538\n",
"Frame N 270 1004 1 1116 201\n",
"Frame N 270 938 0 1039 199\n",
"Frame N 270 491 0 613 193\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:03] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 271 0 1 196 349\n",
"Frame N 271 328 430 433 534\n",
"Frame N 271 514 1 923 538\n",
"Frame N 271 359 87 476 202\n",
"Frame N 271 996 1 1106 201\n",
"Frame N 271 483 287 545 336\n",
"Frame N 271 476 0 596 193\n",
"Frame N 271 928 0 1028 196\n",
"Frame N 271 475 2 671 335\n",
"Frame N 271 963 108 1008 200\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:03] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 272 0 1 178 349\n",
"Frame N 272 513 1 925 538\n",
"Frame N 272 330 433 437 536\n",
"Frame N 272 985 0 1098 199\n",
"Frame N 272 344 84 461 200\n",
"Frame N 272 461 0 586 191\n",
"Frame N 272 468 287 536 338\n",
"Frame N 272 941 107 996 199\n",
"Frame N 272 917 3 1020 192\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:03] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 273 10 1 161 350\n",
"Frame N 273 332 434 441 538\n",
"Frame N 273 500 1 899 542\n",
"Frame N 273 328 83 447 200\n",
"Frame N 273 973 0 1086 199\n",
"Frame N 273 453 287 520 338\n",
"Frame N 273 446 0 574 190\n",
"Frame N 273 906 2 1003 195\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:04] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 274 335 435 443 541\n",
"Frame N 274 0 1 141 350\n",
"Frame N 274 471 1 891 544\n",
"Frame N 274 432 0 561 191\n",
"Frame N 274 312 80 433 198\n",
"Frame N 274 964 0 1078 198\n",
"Frame N 274 438 286 507 339\n",
"Frame N 274 930 101 978 198\n",
"Frame N 274 896 2 992 194\n",
"Frame N 274 106 65 181 117\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:04] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 275 0 1 126 351\n",
"Frame N 275 338 437 448 544\n",
"Frame N 275 465 0 858 547\n",
"Frame N 275 295 79 418 198\n",
"Frame N 275 951 0 1068 197\n",
"Frame N 275 426 286 493 339\n",
"Frame N 275 417 0 547 196\n",
"Frame N 275 414 0 607 354\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:04] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 276 0 1 126 351\n",
"Frame N 276 338 437 447 543\n",
"Frame N 276 465 0 858 547\n",
"Frame N 276 295 79 418 198\n",
"Frame N 276 952 0 1068 197\n",
"Frame N 276 426 286 493 339\n",
"Frame N 276 416 0 547 196\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:04] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 277 446 1 859 551\n",
"Frame N 277 342 439 453 546\n",
"Frame N 277 280 78 402 197\n",
"Frame N 277 0 1 108 351\n",
"Frame N 277 946 0 1058 197\n",
"Frame N 277 411 287 481 339\n",
"Frame N 277 402 0 534 193\n",
"Frame N 277 874 1 971 192\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:05] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 278 433 1 854 552\n",
"Frame N 278 346 441 458 547\n",
"Frame N 278 264 77 389 197\n",
"Frame N 278 387 0 519 192\n",
"Frame N 278 933 0 1049 197\n",
"Frame N 278 396 287 466 340\n",
"Frame N 278 489 93 546 194\n",
"Frame N 278 -1 0 92 350\n",
"Frame N 278 901 99 948 196\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:05] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 279 439 2 856 553\n",
"Frame N 279 351 444 465 549\n",
"Frame N 279 249 75 375 196\n",
"Frame N 279 373 0 506 191\n",
"Frame N 279 922 0 1040 197\n",
"Frame N 279 383 287 453 341\n",
"Frame N 279 477 94 537 196\n",
"Frame N 279 39 59 116 112\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:05] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 280 441 1 858 556\n",
"Frame N 280 356 445 470 551\n",
"Frame N 280 235 75 360 196\n",
"Frame N 280 913 0 1030 197\n",
"Frame N 280 369 287 439 343\n",
"Frame N 280 360 0 495 191\n",
"Frame N 280 464 94 529 196\n",
"Frame N 280 844 0 944 52\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:05] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 281 442 0 860 556\n",
"Frame N 281 363 448 477 554\n",
"Frame N 281 220 73 347 197\n",
"Frame N 281 348 0 482 189\n",
"Frame N 281 356 288 426 344\n",
"Frame N 281 901 0 1020 198\n",
"Frame N 281 450 93 529 197\n",
"Frame N 281 -4 0 45 352\n",
"Frame N 281 870 97 917 195\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:06] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 282 442 0 860 556\n",
"Frame N 282 363 448 477 554\n",
"Frame N 282 220 73 347 197\n",
"Frame N 282 348 0 482 189\n",
"Frame N 282 356 288 426 344\n",
"Frame N 282 900 0 1020 198\n",
"Frame N 282 450 93 529 197\n",
"Frame N 282 -4 0 46 350\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:06] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 283 396 0 864 558\n",
"Frame N 283 370 451 481 556\n",
"Frame N 283 208 74 335 197\n",
"Frame N 283 892 0 1011 197\n",
"Frame N 283 336 0 470 190\n",
"Frame N 283 439 94 522 198\n",
"Frame N 283 344 289 415 344\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:06] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 284 343 1 865 562\n",
"Frame N 284 196 74 323 198\n",
"Frame N 284 374 453 490 558\n",
"Frame N 284 322 0 458 192\n",
"Frame N 284 883 0 1000 198\n",
"Frame N 284 428 95 508 199\n",
"Frame N 284 331 290 402 346\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:07] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 285 327 1 868 563\n",
"Frame N 285 370 462 486 562\n",
"Frame N 285 182 74 311 198\n",
"Frame N 285 310 0 446 191\n",
"Frame N 285 849 0 990 199\n",
"Frame N 285 319 291 390 347\n",
"Frame N 285 415 94 499 200\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:07] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 286 322 0 866 564\n",
"Frame N 286 361 466 474 564\n",
"Frame N 286 172 76 299 200\n",
"Frame N 286 403 95 486 201\n",
"Frame N 286 300 0 434 195\n",
"Frame N 286 855 0 980 200\n",
"Frame N 286 307 292 381 347\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:07] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 287 316 1 869 567\n",
"Frame N 287 352 460 466 567\n",
"Frame N 287 160 76 288 202\n",
"Frame N 287 851 0 970 201\n",
"Frame N 287 288 0 423 199\n",
"Frame N 287 395 96 477 202\n",
"Frame N 287 296 294 368 350\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:07] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 288 316 1 869 567\n",
"Frame N 288 352 460 466 567\n",
"Frame N 288 160 76 288 202\n",
"Frame N 288 851 0 970 201\n",
"Frame N 288 288 0 423 198\n",
"Frame N 288 395 96 477 202\n",
"Frame N 288 296 294 368 350\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:08] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 289 313 2 867 570\n",
"Frame N 289 343 454 460 569\n",
"Frame N 289 148 78 277 204\n",
"Frame N 289 277 0 413 200\n",
"Frame N 289 838 0 958 204\n",
"Frame N 289 285 296 359 351\n",
"Frame N 289 382 97 465 204\n",
"Frame N 289 1136 176 1254 201\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:08] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 290 309 2 869 573\n",
"Frame N 290 334 448 454 565\n",
"Frame N 290 268 0 402 202\n",
"Frame N 290 138 80 267 206\n",
"Frame N 290 830 0 950 206\n",
"Frame N 290 373 100 452 206\n",
"Frame N 290 274 298 349 354\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:08] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 291 328 1 871 575\n",
"Frame N 291 326 444 445 559\n",
"Frame N 291 129 84 256 208\n",
"Frame N 291 257 0 391 203\n",
"Frame N 291 824 1 939 208\n",
"Frame N 291 265 301 337 357\n",
"Frame N 291 497 39 598 196\n",
"Frame N 291 365 102 443 208\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:08] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 292 334 1 871 577\n",
"Frame N 292 318 437 437 555\n",
"Frame N 292 119 86 247 211\n",
"Frame N 292 247 0 383 207\n",
"Frame N 292 255 303 329 360\n",
"Frame N 292 823 1 929 212\n",
"Frame N 292 353 105 434 209\n",
"Frame N 292 487 36 601 195\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:09] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 293 343 2 873 580\n",
"Frame N 293 311 432 429 551\n",
"Frame N 293 238 0 373 209\n",
"Frame N 293 108 88 237 214\n",
"Frame N 293 468 44 605 205\n",
"Frame N 293 821 1 918 215\n",
"Frame N 293 342 107 425 214\n",
"Frame N 293 245 306 319 362\n",
"Frame N 293 341 397 490 463\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:09] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 294 344 2 873 580\n",
"Frame N 294 311 432 430 551\n",
"Frame N 294 238 0 373 209\n",
"Frame N 294 108 88 237 214\n",
"Frame N 294 468 44 605 204\n",
"Frame N 294 821 1 918 214\n",
"Frame N 294 342 107 426 214\n",
"Frame N 294 245 306 319 362\n",
"Frame N 294 341 397 490 463\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:09] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 295 354 1 876 582\n",
"Frame N 295 304 429 423 548\n",
"Frame N 295 99 92 227 216\n",
"Frame N 295 229 0 362 211\n",
"Frame N 295 235 308 307 364\n",
"Frame N 295 470 45 597 207\n",
"Frame N 295 825 1 908 216\n",
"Frame N 295 333 111 415 216\n",
"Frame N 295 1086 189 1205 214\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:09] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 296 362 2 882 585\n",
"Frame N 296 296 424 417 544\n",
"Frame N 296 218 0 353 216\n",
"Frame N 296 88 94 216 219\n",
"Frame N 296 447 49 589 219\n",
"Frame N 296 324 113 408 219\n",
"Frame N 296 225 312 299 367\n",
"Frame N 296 507 0 628 217\n",
"Frame N 296 821 76 899 218\n",
"Frame N 296 1074 192 1195 216\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:10] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 297 380 2 883 589\n",
"Frame N 297 289 420 411 540\n",
"Frame N 297 209 0 342 218\n",
"Frame N 297 79 97 208 222\n",
"Frame N 297 437 53 578 216\n",
"Frame N 297 316 115 397 221\n",
"Frame N 297 217 313 289 371\n",
"Frame N 297 508 1 624 220\n",
"Frame N 297 1065 194 1183 220\n",
"Frame N 297 818 95 887 221\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:10] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 298 398 2 877 594\n",
"Frame N 298 282 417 405 538\n",
"Frame N 298 200 0 335 220\n",
"Frame N 298 69 102 199 224\n",
"Frame N 298 431 54 570 224\n",
"Frame N 298 207 317 280 373\n",
"Frame N 298 305 118 384 223\n",
"Frame N 298 1055 197 1173 223\n",
"Frame N 298 507 0 616 227\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:10] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 299 416 2 875 593\n",
"Frame N 299 277 413 397 534\n",
"Frame N 299 60 103 190 228\n",
"Frame N 299 192 0 326 224\n",
"Frame N 299 419 56 561 229\n",
"Frame N 299 199 320 271 377\n",
"Frame N 299 496 0 602 229\n",
"Frame N 299 296 122 379 227\n",
"Frame N 299 1044 201 1163 227\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:11] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 300 416 2 874 593\n",
"Frame N 300 277 413 397 534\n",
"Frame N 300 60 103 190 228\n",
"Frame N 300 192 0 326 224\n",
"Frame N 300 418 57 561 229\n",
"Frame N 300 199 320 271 377\n",
"Frame N 300 497 0 602 229\n",
"Frame N 300 297 122 379 227\n",
"Frame N 300 1044 201 1163 227\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:11] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 301 437 1 876 594\n",
"Frame N 301 271 409 392 531\n",
"Frame N 301 53 108 183 230\n",
"Frame N 301 184 0 318 227\n",
"Frame N 301 191 323 262 379\n",
"Frame N 301 417 61 552 232\n",
"Frame N 301 288 127 371 232\n",
"Frame N 301 1031 204 1150 230\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:11] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 302 452 1 873 594\n",
"Frame N 302 266 405 387 527\n",
"Frame N 302 47 111 176 235\n",
"Frame N 302 176 1 309 232\n",
"Frame N 302 183 326 255 382\n",
"Frame N 302 401 66 542 235\n",
"Frame N 302 280 130 364 235\n",
"Frame N 302 1022 208 1136 233\n",
"Frame N 302 471 -1 587 234\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:12] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 303 460 2 872 597\n",
"Frame N 303 261 404 382 524\n",
"Frame N 303 40 116 167 238\n",
"Frame N 303 169 0 302 236\n",
"Frame N 303 176 329 248 385\n",
"Frame N 303 397 73 532 237\n",
"Frame N 303 272 135 348 239\n",
"Frame N 303 205 396 228 417\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:12] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 304 461 1 871 598\n",
"Frame N 304 257 401 377 520\n",
"Frame N 304 162 0 295 241\n",
"Frame N 304 37 123 162 244\n",
"Frame N 304 267 140 349 243\n",
"Frame N 304 389 76 523 243\n",
"Frame N 304 1222 4 1281 237\n",
"Frame N 304 171 330 241 387\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:12] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 305 462 2 866 601\n",
"Frame N 305 158 0 287 246\n",
"Frame N 305 254 396 373 517\n",
"Frame N 305 32 128 157 247\n",
"Frame N 305 376 83 515 247\n",
"Frame N 305 257 145 336 248\n",
"Frame N 305 1206 2 1280 243\n",
"Frame N 305 165 337 235 390\n",
"Frame N 305 980 222 1095 246\n",
"Frame N 305 586 1 700 166\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:13] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 306 462 2 866 601\n",
"Frame N 306 158 0 287 246\n",
"Frame N 306 254 396 373 516\n",
"Frame N 306 32 128 157 247\n",
"Frame N 306 376 83 515 247\n",
"Frame N 306 257 145 336 248\n",
"Frame N 306 1206 2 1280 243\n",
"Frame N 306 165 337 235 390\n",
"Frame N 306 980 222 1095 246\n",
"Frame N 306 587 1 700 167\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:13] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 307 464 1 863 602\n",
"Frame N 307 250 393 369 513\n",
"Frame N 307 28 133 150 251\n",
"Frame N 307 153 0 280 249\n",
"Frame N 307 370 90 505 253\n",
"Frame N 307 254 152 331 252\n",
"Frame N 307 1190 2 1281 249\n",
"Frame N 307 159 340 227 401\n",
"Frame N 307 572 0 698 180\n",
"Frame N 307 966 226 1079 250\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:13] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 308 473 1 858 603\n",
"Frame N 308 247 396 365 512\n",
"Frame N 308 22 140 145 257\n",
"Frame N 308 148 0 275 251\n",
"Frame N 308 1173 2 1280 254\n",
"Frame N 308 362 95 497 257\n",
"Frame N 308 247 157 321 257\n",
"Frame N 308 154 344 221 400\n",
"Frame N 308 399 0 531 256\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:14] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 309 143 0 267 256\n",
"Frame N 309 475 2 853 605\n",
"Frame N 309 244 393 362 509\n",
"Frame N 309 21 145 142 260\n",
"Frame N 309 1155 0 1271 258\n",
"Frame N 309 357 103 488 260\n",
"Frame N 309 149 348 217 401\n",
"Frame N 309 240 162 313 262\n",
"Frame N 309 411 1 530 262\n",
"Frame N 309 937 237 1049 261\n",
"Frame N 309 551 0 692 215\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:14] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 310 138 0 262 263\n",
"Frame N 310 240 392 356 506\n",
"Frame N 310 476 2 850 606\n",
"Frame N 310 19 152 134 266\n",
"Frame N 310 402 1 516 264\n",
"Frame N 310 344 110 478 264\n",
"Frame N 310 236 169 307 267\n",
"Frame N 310 1139 4 1253 263\n",
"Frame N 310 144 352 211 403\n",
"Frame N 310 534 0 687 228\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:15] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 311 132 1 254 267\n",
"Frame N 311 237 392 353 503\n",
"Frame N 311 479 2 845 606\n",
"Frame N 311 16 158 131 271\n",
"Frame N 311 339 117 469 267\n",
"Frame N 311 395 1 508 269\n",
"Frame N 311 139 355 206 406\n",
"Frame N 311 1120 1 1233 267\n",
"Frame N 311 228 176 295 270\n",
"Frame N 311 530 2 673 265\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:15] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 312 132 1 254 267\n",
"Frame N 312 237 392 353 503\n",
"Frame N 312 479 2 845 606\n",
"Frame N 312 16 158 131 271\n",
"Frame N 312 339 117 469 268\n",
"Frame N 312 395 0 508 269\n",
"Frame N 312 139 355 206 406\n",
"Frame N 312 1120 0 1232 267\n",
"Frame N 312 228 176 295 270\n",
"Frame N 312 530 2 672 265\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:15] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 313 481 1 841 605\n",
"Frame N 313 235 391 348 503\n",
"Frame N 313 127 8 247 273\n",
"Frame N 313 14 164 126 276\n",
"Frame N 313 1105 0 1215 274\n",
"Frame N 313 515 0 663 274\n",
"Frame N 313 385 1 498 276\n",
"Frame N 313 332 122 461 275\n",
"Frame N 313 135 360 200 410\n",
"Frame N 313 223 180 300 276\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:16] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 314 232 393 345 504\n",
"Frame N 314 484 2 836 606\n",
"Frame N 314 123 15 243 277\n",
"Frame N 314 1087 2 1195 279\n",
"Frame N 314 11 171 121 282\n",
"Frame N 314 510 1 672 279\n",
"Frame N 314 376 0 485 279\n",
"Frame N 314 218 188 291 282\n",
"Frame N 314 129 361 194 412\n",
"Frame N 314 326 131 452 282\n",
"Frame N 314 880 257 985 280\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:16] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 315 484 1 834 607\n",
"Frame N 315 231 394 341 503\n",
"Frame N 315 119 25 237 281\n",
"Frame N 315 1067 9 1177 285\n",
"Frame N 315 498 4 674 283\n",
"Frame N 315 369 1 480 285\n",
"Frame N 315 9 177 117 285\n",
"Frame N 315 126 358 188 416\n",
"Frame N 315 315 137 442 283\n",
"Frame N 315 210 194 280 284\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:16] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 316 487 2 830 607\n",
"Frame N 316 229 393 338 502\n",
"Frame N 316 114 31 230 285\n",
"Frame N 316 1049 18 1157 288\n",
"Frame N 316 360 0 467 288\n",
"Frame N 316 7 184 112 290\n",
"Frame N 316 487 3 662 286\n",
"Frame N 316 309 143 434 291\n",
"Frame N 316 121 369 183 421\n",
"Frame N 316 205 200 279 290\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:17] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 317 490 3 826 607\n",
"Frame N 317 225 393 335 502\n",
"Frame N 317 474 2 643 295\n",
"Frame N 317 1030 28 1137 293\n",
"Frame N 317 110 41 224 293\n",
"Frame N 317 352 1 459 295\n",
"Frame N 317 5 190 108 296\n",
"Frame N 317 303 149 424 295\n",
"Frame N 317 117 374 177 422\n",
"Frame N 317 200 206 269 296\n",
"Frame N 317 833 272 935 294\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:17] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 318 489 3 826 607\n",
"Frame N 318 225 393 335 502\n",
"Frame N 318 474 2 643 295\n",
"Frame N 318 1030 28 1137 293\n",
"Frame N 318 110 41 224 293\n",
"Frame N 318 352 1 459 295\n",
"Frame N 318 5 190 108 296\n",
"Frame N 318 303 149 424 295\n",
"Frame N 318 117 374 177 422\n",
"Frame N 318 200 206 267 296\n",
"Frame N 318 833 272 935 294\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:17] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 319 492 3 819 607\n",
"Frame N 319 221 396 332 503\n",
"Frame N 319 1013 36 1118 296\n",
"Frame N 319 106 49 218 297\n",
"Frame N 319 345 8 451 297\n",
"Frame N 319 468 2 654 300\n",
"Frame N 319 3 196 104 300\n",
"Frame N 319 112 377 173 427\n",
"Frame N 319 300 157 416 298\n",
"Frame N 319 194 212 262 300\n",
"Frame N 319 576 76 662 298\n",
"Frame N 319 1191 396 1283 717\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:18] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 320 219 396 328 502\n",
"Frame N 320 1000 44 1098 302\n",
"Frame N 320 496 4 811 607\n",
"Frame N 320 101 58 214 302\n",
"Frame N 320 460 1 623 301\n",
"Frame N 320 1 202 100 304\n",
"Frame N 320 339 16 441 304\n",
"Frame N 320 285 165 407 304\n",
"Frame N 320 109 380 168 429\n",
"Frame N 320 1197 380 1280 495\n",
"Frame N 320 1175 377 1281 716\n",
"Frame N 320 804 283 903 304\n",
"Frame N 320 190 217 252 301\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:18] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 321 501 5 803 608\n",
"Frame N 321 218 397 324 502\n",
"Frame N 321 979 53 1080 307\n",
"Frame N 321 97 66 208 307\n",
"Frame N 321 450 4 610 307\n",
"Frame N 321 0 207 96 309\n",
"Frame N 321 332 25 432 307\n",
"Frame N 321 281 171 399 309\n",
"Frame N 321 1178 308 1278 506\n",
"Frame N 321 104 384 161 430\n",
"Frame N 321 183 223 251 310\n",
"Frame N 321 1155 476 1282 717\n",
"Frame N 321 552 96 634 311\n",
"Frame N 321 1179 367 1277 505\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:18] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 322 95 74 202 310\n",
"Frame N 322 507 3 795 608\n",
"Frame N 322 215 397 321 502\n",
"Frame N 322 961 62 1062 312\n",
"Frame N 322 439 9 626 312\n",
"Frame N 322 323 34 420 312\n",
"Frame N 322 0 214 92 313\n",
"Frame N 322 277 178 390 314\n",
"Frame N 322 178 228 243 313\n",
"Frame N 322 100 388 157 431\n",
"Frame N 322 542 107 625 316\n",
"Frame N 322 1138 477 1278 719\n",
"Frame N 322 1162 295 1275 519\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:18] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 323 510 2 788 609\n",
"Frame N 323 91 82 197 314\n",
"Frame N 323 944 70 1043 316\n",
"Frame N 323 214 399 319 503\n",
"Frame N 323 313 42 415 315\n",
"Frame N 323 0 220 88 317\n",
"Frame N 323 268 184 382 318\n",
"Frame N 323 436 21 610 311\n",
"Frame N 323 525 120 614 319\n",
"Frame N 323 96 390 152 435\n",
"Frame N 323 1128 186 1257 713\n",
"Frame N 323 588 3 643 99\n",
"Frame N 323 173 235 225 316\n",
"Frame N 323 410 1 480 61\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:19] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 324 510 2 787 609\n",
"Frame N 324 91 82 197 314\n",
"Frame N 324 944 70 1043 316\n",
"Frame N 324 214 399 319 503\n",
"Frame N 324 313 42 415 315\n",
"Frame N 324 0 220 88 317\n",
"Frame N 324 268 184 382 318\n",
"Frame N 324 436 22 611 311\n",
"Frame N 324 525 120 614 319\n",
"Frame N 324 96 390 152 435\n",
"Frame N 324 1128 177 1257 713\n",
"Frame N 324 588 3 643 99\n",
"Frame N 324 173 234 225 316\n",
"Frame N 324 410 1 480 61\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"[2023-08-01 14:51:19] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Frame N 325 513 2 783 608\n",
"Frame N 325 212 403 315 503\n",
"Frame N 325 86 90 191 320\n",
"Frame N 325 927 77 1025 321\n",
"Frame N 325 422 30 578 319\n",
"Frame N 325 308 50 404 320\n",
"Frame N 325 0 226 85 321\n",
"Frame N 325 259 191 374 322\n",
"Frame N 325 518 116 605 323\n",
"Frame N 325 93 394 147 438\n",
"Frame N 325 1116 205 1232 714\n",
"Frame N 325 577 1 631 111\n",
"Frame N 325 168 240 231 322\n",
"Frame N 325 939 1 1033 32\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"#**Step 07: Display the Output Demo Video**"
],
"metadata": {
"id": "80QfwAWANh6S"
}
},
{
"cell_type": "code",
"source": [
"!rm '/content/result_compressed.mp4'\n"
],
"metadata": {
"id": "fPZTJi-JNocF"
},
"execution_count": 31,
"outputs": []
},
{
"cell_type": "code",
"source": [
"from IPython.display import HTML\n",
"from base64 import b64encode\n",
"import os\n",
"\n",
"# Input video path\n",
"save_path = '/content/Output1.avi'\n",
"\n",
"# Compressed video path\n",
"compressed_path = \"/content/result_compressed.mp4\"\n",
"\n",
"os.system(f\"ffmpeg -i {save_path} -vcodec libx264 {compressed_path}\")\n",
"\n",
"# Show video\n",
"mp4 = open(compressed_path,'rb').read()\n",
"data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
"HTML(\"\"\"\n",
"\n",
"\"\"\" % data_url)"
],
"metadata": {
"id": "4gJeB2saNoed",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 247
},
"outputId": "4f4a3ee7-cd14-4d17-9f0a-ecfedd4651f6"
},
"execution_count": 33,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
""
],
"text/html": [
"\n",
"